home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 38 / Amiga Format CD38 (1999-03-15)(Future Publishing)(GB)(Track 1 of 3)[!][issue 1999-04].iso / -seriously_amiga- / programming / other / cyberxxxsrc / cyberavi / txt / cyberavivideo.mod < prev   
Text File  |  1999-02-08  |  73KB  |  2,032 lines
  1. MODULE  CyberAVIVideo;
  2.  
  3. (* $IFNOT DEBUG *)
  4.   (* $StackChk- $OvflChk- $RangeChk- $CaseChk- $ReturnChk- $NilChk- $TypeChk- $OddChk- $ClearVars- *)
  5. (* $END *)
  6.  
  7. (* /// ------------------------------- "IMPORT" -------------------------------- *)
  8. IMPORT  b:=BestModeID,
  9.         cu:=CyberAVIUtils,
  10.         cgfx:=CyberGraphics,
  11.         d:=Dos,
  12.         e:=Exec,
  13.         g:=CyberAVIGlobals,
  14.         gfx:=Graphics,
  15.         i:=Intuition,
  16.         iff:=IFFParse,
  17.         io:=AsyncIOSupport,
  18.         i2m:=Intel2Mot,
  19.         lv:=LibraryVer,
  20.         mu:=MathUtils,
  21.         o:=CyberAVIOpts,
  22.         ol:=OberonLib,
  23.         s:=CyberAVISync,
  24.         sl:=StringLib,
  25.         u:=Utility,
  26.         y:=SYSTEM,
  27.         ys:=YUVStuff;
  28. (* \\\ ------------------------------------------------------------------------- *)
  29.  
  30. (* /// -------------------------------- "CONST" -------------------------------- *)
  31. CONST   idmsvc=y.VAL(LONGINT,"msvc");
  32.         idMSVC=y.VAL(LONGINT,"MSVC");
  33.         idCRAM=y.VAL(LONGINT,"CRAM");
  34.         idrgb =y.VAL(LONGINT,"\x00\x00\x00\x00");
  35.         idRGB =y.VAL(LONGINT,"RGB ");
  36.         idrle8=y.VAL(LONGINT,"\x01\x00\x00\x00");
  37.         idRLE8=y.VAL(LONGINT,"RLE8");
  38.         idrle4=y.VAL(LONGINT,"\x02\x00\x00\x00");
  39.         idRLE4=y.VAL(LONGINT,"RLE4");
  40.         idnone=y.VAL(LONGINT,"\x00\x00\xFF\xFF");
  41.         idNONE=y.VAL(LONGINT,"NONE");
  42.         idpack=y.VAL(LONGINT,"\x01\x00\xFF\xFF");
  43.         idPACK=y.VAL(LONGINT,"PACK");
  44.         idtran=y.VAL(LONGINT,"\x02\x00\xFF\xFF");
  45.         idTRAN=y.VAL(LONGINT,"TRAN");
  46.         idccc =y.VAL(LONGINT,"\x03\x00\xFF\xFF");
  47.         idCCC =y.VAL(LONGINT,"CCC ");
  48.         idjpeg=y.VAL(LONGINT,"\x04\x00\xFF\xFF");
  49.         idJPEG=y.VAL(LONGINT,"JPEG");
  50.         idmJPG=y.VAL(LONGINT,"mJPG");
  51.         idMJPG=y.VAL(LONGINT,"MJPG");
  52.         idIJPG=y.VAL(LONGINT,"IJPG");
  53.         idRT21=y.VAL(LONGINT,"RT21");
  54.         idrt21=y.VAL(LONGINT,"rt21");
  55.         idIV31=y.VAL(LONGINT,"IV31");
  56.         idiv31=y.VAL(LONGINT,"iv31");
  57.         idIV32=y.VAL(LONGINT,"IV32");
  58.         idiv32=y.VAL(LONGINT,"iv32");
  59.         idIV41=y.VAL(LONGINT,"IV41");
  60.         idiv41=y.VAL(LONGINT,"iv41");
  61.         idCVID=y.VAL(LONGINT,"CVID");
  62.         idcvid=y.VAL(LONGINT,"cvid");
  63.         idRPZA=y.VAL(LONGINT,"RPZA");
  64.         idrpza=y.VAL(LONGINT,"rpza");
  65.         idAZPR=y.VAL(LONGINT,"AZPR");
  66.         idazpr=y.VAL(LONGINT,"azpr");
  67.         idULTI=y.VAL(LONGINT,"ULTI");
  68.         idulti=y.VAL(LONGINT,"ulti");
  69.         idYUV2=y.VAL(LONGINT,"YUV2");
  70.         idyuv2=y.VAL(LONGINT,"yuv2");
  71.         id2VUY=y.VAL(LONGINT,"2VUY");
  72.         id2vuy=y.VAL(LONGINT,"2vuy");
  73.         idYUV9=y.VAL(LONGINT,"YUV9");
  74.         idYVU9=y.VAL(LONGINT,"YVU9");
  75.         id9VUY=y.VAL(LONGINT,"9VUY");
  76.         id9UVY=y.VAL(LONGINT,"9UVY");
  77.         idVYUY=y.VAL(LONGINT,"VYUY");
  78.         idYV12=y.VAL(LONGINT,"YV12");
  79.         idyv12=y.VAL(LONGINT,"yv12");
  80.         idXMPG=y.VAL(LONGINT,"XMPG");
  81.         idxmpg=y.VAL(LONGINT,"xmpg");
  82.         idCYUV=y.VAL(LONGINT,"CYUV");
  83.         idcyuv=y.VAL(LONGINT,"cyuv");
  84.         idVDOW=y.VAL(LONGINT,"VDOW");
  85.  
  86.         codecSupported * =1;
  87.         codecUnknown * =0;
  88.         codecUnsupported * =-1;
  89.  
  90.         tmpRasSize=4096;
  91. (* \\\ ------------------------------------------------------------------------- *)
  92.  
  93. (* /// -------------------------------- "TYPE" --------------------------------- *)
  94. TYPE    CodecHeader=STRUCT
  95.             compression: LONGINT;
  96.             width: LONGINT;
  97.             height: LONGINT;
  98.             depth: LONGINT;
  99.             description: e.STRING;
  100.         END;
  101.  
  102.         DecoderProc=PROCEDURE(from{8}: e.APTR;
  103.                               to{9}: e.APTR;
  104.                               width{0}: LONGINT;
  105.                               height{1}: LONGINT;
  106.                               encSize{2}: LONGINT;
  107.                               spec{10}: e.APTR);
  108.  
  109.         FastC2PProc=PROCEDURE(chunky{8}: e.APTR;
  110.                               bitmap{9}: gfx.BitMapPtr;
  111.                               realWidth{1}: LONGINT);
  112.  
  113.         DisplayProc=PROCEDURE();
  114.  
  115.         ColorReg=STRUCT
  116.             red: LONGINT;
  117.             green: LONGINT;
  118.             blue: LONGINT;
  119.         END;
  120.         ColorRegArrayPtr=UNTRACED POINTER TO ColorRegArray;
  121.         ColorRegArray=ARRAY 256 OF ColorReg;
  122.  
  123.         ColorMapPtr=UNTRACED POINTER TO ColorMap;
  124.         ColorMap=STRUCT
  125.             count: INTEGER;
  126.             first: INTEGER;
  127.             colors: ColorRegArray;
  128.             last: LONGINT;
  129.         END;
  130.         ColorMapArrayPtr=UNTRACED POINTER TO ColorMapArray;
  131.         ColorMapArray=ARRAY SIZE(ColorMap) DIV SIZE(LONGINT) OF LONGINT;
  132.  
  133.         CMapArrPtr=UNTRACED POINTER TO CMapArr;
  134.         CMapArr=ARRAY 256 OF STRUCT
  135.             alpha: CHAR;
  136.             red: CHAR;
  137.             green: CHAR;
  138.             blue: CHAR;
  139.         END;
  140. (* \\\ ------------------------------------------------------------------------- *)
  141.  
  142. (* /// --------------------------------- "VAR" --------------------------------- *)
  143. VAR     screen: i.ScreenPtr;
  144.         window: i.WindowPtr;
  145.         mouse: i.ObjectPtr;
  146.         mouseBitMap: gfx.BitMapPtr;
  147.         colorReduction: BOOLEAN;
  148.         ham8: BOOLEAN;
  149.         animWidth: INTEGER;
  150.         animHeight: INTEGER;
  151.         animDepth: INTEGER;
  152.         dispModulo: INTEGER;
  153.         calcWidth: LONGINT;
  154.         calcHeight: LONGINT;
  155.         colorMap: ColorMapPtr;
  156.         secondColorMap: ColorMapPtr;
  157.         videoBufferSize: LONGINT;
  158.         videoData: e.LSTRPTR;
  159.         videoDataDec: e.LSTRPTR;
  160.         ham8Buffer: e.LSTRPTR;
  161.         decoderProc: DecoderProc;
  162.         rawDecoderProc: DecoderProc;
  163.         displayProc: DisplayProc;
  164.         fastc2pProc: FastC2PProc;
  165.         decoderSpec: e.APTR;
  166.         idcmpSig - : LONGINT;
  167.         leftOff: INTEGER;
  168.         topOff: INTEGER;
  169.         rp: gfx.RastPortPtr;
  170.         tmpBM: gfx.BitMapPtr;
  171.         tmpRas: gfx.TmpRasPtr;
  172.         tmpRasMem: UNTRACED POINTER TO ARRAY tmpRasSize OF CHAR;
  173.         grayScale: BOOLEAN;
  174.         pubScreen: BOOLEAN;
  175.         colorType: LONGINT;
  176.         frameSize: LONGINT;
  177.         cmap: CMapArrPtr;
  178.         secondCmap: CMapArrPtr;
  179.         doubleScanned - : BOOLEAN;
  180. (* \\\ ------------------------------------------------------------------------- *)
  181.  
  182. (* /// ----------------------- "PROCEDURE HandleIDCMP()" ----------------------- *)
  183. PROCEDURE HandleIDCMP * (): LONGINT;
  184.  
  185. VAR     msg: i.IntuiMessagePtr;
  186.         ret: LONGINT;
  187.  
  188. BEGIN
  189.   ret:=g.noError;
  190.   msg:=e.GetMsg(window.userPort);
  191.   IF msg#NIL THEN
  192.     IF i.vanillaKey IN msg.class THEN
  193.       CASE msg.code OF
  194.       | 3: ret:=d.break; (* CTRL-C *)
  195.       | 4: ret:=g.skipAnim; (* CTRL-D *)
  196.       | 27: ret:=g.skipAnim; (* ESC *)
  197.       | ORD("P"), ORD("p"): ret:=g.pauseAnim;
  198.       ELSE
  199.       END;
  200.     ELSIF i.rawKey IN msg.class THEN
  201.       CASE msg.code OF
  202.       | 69: ret:=g.skipAnim     (* ESC *)
  203.       | 80: s.SetFrameDelay(0);      (* F1, maximal *)
  204.       | 81: s.SetFrameDelay(16666);  (* F2, 60 fps*)
  205.       | 82: s.SetFrameDelay(33333);  (* F3, 30 fps *)
  206.       | 83: s.SetFrameDelay(41666);  (* F4, 24 fps*)
  207.       | 84: s.SetFrameDelay(66666);  (* F5, 15 fps *)
  208.       | 85: s.SetFrameDelay(83333);  (* F6, 12 fps *)
  209.       | 86: s.SetFrameDelay(100000); (* F7, 10 fps *)
  210.       | 87: s.SetFrameDelay(200000); (* F8, 5 fps *)
  211.       | 88: s.SetFrameDelay(999999); (* F9, 1 fps*)
  212.       | 89: s.SetFrameDelay(-1);     (* F10, normal*)
  213.       ELSE
  214.       END;
  215.     ELSE
  216.       ret:=g.skipAnim;
  217.     END;
  218.     e.ReplyMsg(msg);
  219.   END;
  220.   RETURN ret;
  221. END HandleIDCMP;
  222. (* \\\ ------------------------------------------------------------------------- *)
  223.  
  224. (* /// ------------------- "PROCEDURE ReadExternalPalette()" ------------------- *)
  225. PROCEDURE ReadExternalPalette();
  226.  
  227. CONST   idILBM=y.VAL(LONGINT,"ILBM");
  228.         idCMAP=y.VAL(LONGINT,"CMAP");
  229.  
  230. VAR     handle: iff.IFFHandlePtr;
  231.         fh: d.FileHandlePtr;
  232.         chunk: iff.ContextNodePtr;
  233.         buffer: ARRAY 768 OF CHAR;
  234.         error: LONGINT;
  235.         cnt: LONGINT;
  236.         numColors: LONGINT;
  237.  
  238. BEGIN
  239.   IF iff.base=NIL THEN RETURN; END;
  240.   handle:=iff.AllocIFF();
  241.   IF handle#NIL THEN
  242.     fh:=d.Open(o.cmap,d.oldFile);
  243.     IF fh#NIL THEN
  244.       handle.stream:=y.VAL(LONGINT,fh);
  245.       iff.InitIFFasDOS(handle);
  246.       IF iff.OpenIFF(handle,iff.read)=0 THEN
  247.         IF iff.StopChunk(handle,idILBM,idCMAP)=0 THEN
  248.           IF iff.ParseIFF(handle,iff.parseScan)=0 THEN
  249.             chunk:=iff.CurrentChunk(handle);
  250.             numColors:=chunk.size DIV 3;
  251.             error:=iff.ReadChunkBytes(handle,buffer,mu.min(chunk.size,SIZE(buffer)));
  252.             FOR cnt:=0 TO numColors-1 DO
  253.               colorMap.colors[cnt].red:=i2m.ByteTo32(buffer[cnt*3+0]);
  254.               colorMap.colors[cnt].green:=i2m.ByteTo32(buffer[cnt*3+1]);
  255.               colorMap.colors[cnt].blue:=i2m.ByteTo32(buffer[cnt*3+2]);
  256.               (* cmap[cnt] nicht setzen, sonst gibts massiv Fehlfarben *)
  257.             END;
  258.             FOR cnt:=numColors TO 255 DO
  259.               colorMap.colors[cnt].red:=0;
  260.               colorMap.colors[cnt].green:=0;
  261.               colorMap.colors[cnt].blue:=0;
  262.             END;
  263.             colorMap.count:=i.LongToUInt(numColors);
  264.             colorMap.first:=0;
  265.             colorMap.last:=numColors-1;
  266.           END;
  267.         END;
  268.         iff.CloseIFF(handle);
  269.       END;
  270.       d.OldClose(fh);
  271.     END;
  272.     iff.FreeIFF(handle);
  273.   END;
  274. END ReadExternalPalette;
  275. (* \\\ ------------------------------------------------------------------------- *)
  276.  
  277. (* /// --------------------- "PROCEDURE Init332ColorMap()" --------------------- *)
  278. PROCEDURE Init332ColorMap();
  279.  
  280. VAR     cnt: LONGINT;
  281.  
  282. BEGIN
  283.   IF colorMap=NIL THEN NEW(colorMap); END;
  284.   FOR cnt:=0 TO 255 DO
  285.     IF grayScale THEN
  286.       colorMap.colors[cnt].red:=i2m.ByteTo32(CHR(cnt));
  287.       colorMap.colors[cnt].green:=i2m.ByteTo32(CHR(cnt));
  288.       colorMap.colors[cnt].blue:=i2m.ByteTo32(CHR(cnt));
  289.       cmap[cnt].red:=CHR(cnt);
  290.       cmap[cnt].green:=CHR(cnt);
  291.       cmap[cnt].blue:=CHR(cnt);
  292.     ELSE
  293.       colorMap.colors[cnt].red:=y.LSH(y.VAL(LONGINT,y.LSH(y.VAL(LONGSET,cnt)*LONGSET{5..7},-5))*9362,16);
  294.       colorMap.colors[cnt].green:=y.LSH(y.VAL(LONGINT,y.LSH(y.VAL(LONGSET,cnt)*LONGSET{2..4},-2))*9362,16);
  295.       colorMap.colors[cnt].blue:=y.LSH(y.VAL(LONGINT,y.VAL(LONGSET,cnt)*LONGSET{0..1})*21845,16);
  296.       cmap[cnt].red:=CHR(y.LSH(y.VAL(LONGINT,y.LSH(y.VAL(LONGSET,cnt)*LONGSET{5..7},-5))*9362,-8));
  297.       cmap[cnt].green:=CHR(y.LSH(y.VAL(LONGINT,y.LSH(y.VAL(LONGSET,cnt)*LONGSET{2..4},-2))*9362,-8));
  298.       cmap[cnt].blue:=CHR(y.LSH(y.VAL(LONGINT,y.VAL(LONGSET,cnt)*LONGSET{0..1})*21845,-8));
  299.     END;
  300.   END;
  301.   colorMap.count:=256;
  302.   colorMap.first:=0;
  303.   colorMap.last:=255;
  304.   IF o.cmap#"" THEN ReadExternalPalette(); END;
  305. END Init332ColorMap;
  306. (* \\\ ------------------------------------------------------------------------- *)
  307.  
  308. (* /// -------------------- "PROCEDURE InitHAM8ColorMap()" --------------------- *)
  309. PROCEDURE InitHAM8ColorMap();
  310.  
  311. VAR     cnt: INTEGER;
  312.         rr: INTEGER;
  313.         gg: INTEGER;
  314.         bb: INTEGER;
  315.  
  316. BEGIN
  317.   IF colorMap=NIL THEN NEW(colorMap); END;
  318.   rr:=0;
  319.   gg:=0;
  320.   bb:=0;
  321.   FOR cnt:=0 TO 63 DO
  322.     colorMap.colors[cnt].red:=y.LSH(rr,30)+y.LSH(rr,24);
  323.     colorMap.colors[cnt].green:=y.LSH(gg,30)+y.LSH(gg,24);
  324.     colorMap.colors[cnt].blue:=y.LSH(bb,30)+y.LSH(bb,24);
  325.     INC(bb);
  326.     IF bb>3 THEN
  327.       bb:=0;
  328.       INC(gg);
  329.       IF gg>3 THEN
  330.         gg:=0;
  331.         INC(rr);
  332.       END;
  333.     END;
  334.   END;
  335.   colorMap.count:=64;
  336.   colorMap.first:=0;
  337.   colorMap.last:=63;
  338. END InitHAM8ColorMap;
  339. (* \\\ ------------------------------------------------------------------------- *)
  340.  
  341. (* /// ---------------------- "PROCEDURE InitTmpBitMap()" ---------------------- *)
  342. PROCEDURE InitTmpBitMap(): LONGINT;
  343. BEGIN
  344.   tmpBM:=gfx.AllocBitMap(animWidth,animHeight,mu.max(animDepth,4),LONGSET{gfx.bmbInterleaved},NIL);
  345.   IF tmpBM=NIL THEN RETURN d.noFreeStore; END;
  346.   IF ~(gfx.bmbInterleaved IN y.VAL(LONGSET,gfx.GetBitMapAttr(tmpBM,gfx.bmaFlags))) THEN RETURN d.noFreeStore; END;
  347.   IF tmpRas=NIL THEN (* tmpRas nur einmal allokieren *)
  348.     NEW(tmpRas);
  349.     INCL(ol.MemReqs,e.chip);
  350.     NEW(tmpRasMem);
  351.     EXCL(ol.MemReqs,e.chip);
  352.     gfx.InitTmpRas(tmpRas^,tmpRasMem,tmpRasSize);
  353.   END;
  354.   rp.tmpRas:=y.ADR(tmpRas);
  355.   RETURN g.noError;
  356. END InitTmpBitMap;
  357. (* \\\ ------------------------------------------------------------------------- *)
  358.  
  359. (* /// ---------------------- "PROCEDURE CloseDisplay()" ----------------------- *)
  360. PROCEDURE CloseDisplay * ();
  361. BEGIN
  362.   IF tmpRas#NIL THEN gfx.WaitBlit(); rp.tmpRas:=NIL; END;
  363.   IF window#NIL THEN i.CloseWindow(window); window:=NIL; END;
  364.   IF screen#NIL THEN
  365.     IF pubScreen THEN
  366.       i.UnlockPubScreen(NIL,screen);
  367.     ELSE
  368.       i.OldCloseScreen(screen);
  369.     END;
  370.     screen:=NIL;
  371.   END;
  372.   IF mouse#NIL THEN i.DisposeObject(mouse); mouse:=NIL; END;
  373.   IF mouseBitMap#NIL THEN gfx.FreeBitMap(mouseBitMap); mouseBitMap:=NIL; END;
  374.   IF tmpBM#NIL THEN gfx.FreeBitMap(tmpBM); tmpBM:=NIL; END;
  375. END CloseDisplay;
  376. (* \\\ ------------------------------------------------------------------------- *)
  377.  
  378. (* /// ----------------------- "PROCEDURE OpenDisplay()" ----------------------- *)
  379. PROCEDURE OpenDisplay * (virtual: BOOLEAN;
  380.                          fileTitle: e.STRPTR): LONGINT;
  381.  
  382. VAR     windowTags: u.Tags20;
  383.         screenDepth: LONGINT;
  384.         errVal: LONGINT;
  385.         cgx3: e.LibraryPtr;
  386.  
  387. CONST   winLeft=0;
  388.         winTop=1;
  389.         winWidth=2;
  390.         winHeight=3;
  391.         winScreen=4;
  392.  
  393. (* /// ---------------------- "PROCEDURE InitPubScreen()" ---------------------- *)
  394.   PROCEDURE InitPubScreen(): LONGINT;
  395.  
  396.   VAR   width: LONGINT;
  397.         height: LONGINT;
  398.         factor: REAL;
  399.  
  400.   CONST winTitle=6;
  401.         winMaxW=7;
  402.         winMaxH=8;
  403.         winMinW=9;
  404.         winMinH=10;
  405.         winSizeGad=15;
  406.  
  407.   BEGIN
  408.     windowTags:=u.Tags20(i.waLeft,0,
  409.                          i.waTop,0,
  410.                          i.waInnerWidth,0,
  411.                          i.waInnerHeight,0,
  412.                          i.waPubScreen,NIL,
  413.                          i.waActivate,e.true,
  414.                          i.waTitle,NIL,
  415.                          i.waMaxWidth,-1,
  416.                          i.waMaxHeight,-1,
  417.                          i.waMinWidth,-1,
  418.                          i.waMinHeight,-1,
  419.                          i.waDragBar,e.true,
  420.                          i.waDepthGadget,e.true,
  421.                          i.waCloseGadget,e.true,
  422.                          i.waAutoAdjust,e.true,
  423.                          i.waSizeGadget,e.true,
  424.                          i.waSizeBBottom,e.true,
  425.                          i.waRMBTrap,e.true,
  426.                          i.waIDCMP,LONGSET{i.closeWindow,i.vanillaKey,i.rawKey},
  427.                          u.done,0);
  428.     screen:=i.LockPubScreen(o.pubScreen);
  429.     IF screen=NIL THEN
  430.       d.PrintF("Can't find screen \"%s\", using own screen\n",y.ADR(o.pubScreen));
  431.       RETURN g.unknownError;
  432.     END;
  433.     width:=gfx.GetBitMapAttr(screen.rastPort.bitMap,gfx.bmaWidth);
  434.     height:=gfx.GetBitMapAttr(screen.rastPort.bitMap,gfx.bmaHeight);
  435.     screenDepth:=gfx.GetBitMapAttr(screen.rastPort.bitMap,gfx.bmaDepth);
  436.     IF (width<calcWidth) OR (height<calcHeight) THEN
  437.       d.PrintF("Screen is too small, using own screen\n");
  438.       RETURN g.unknownError;
  439.     END;
  440.     IF screenDepth<15 THEN
  441.       d.PrintF("Screen \"%s\" is no TrueColor screen, using own screen\n",y.ADR(o.pubScreen));
  442.       RETURN g.unknownError;
  443.     END;
  444.     IF ~cgfx.IsCyberModeID(gfx.GetVPModeID(y.ADR(screen.viewPort))) THEN
  445.       d.PrintF("Screen \"%s\" is not a CyberGraphX native screen, using own screen\n",y.ADR(o.pubScreen));
  446.       RETURN g.unknownError;
  447.     END;
  448.  
  449.     IF o.magnify<0 THEN
  450.       factor:=1/(-o.magnify);
  451.     ELSE
  452.       factor:=o.magnify;
  453.     END;
  454.     IF (animDepth<=8) & grayScale THEN (* 8bit Graustufen => Truecolor *)
  455.       windowTags[winSizeGad].data:=e.false;
  456.       factor:=1.0;
  457.     END;
  458.     doubleScanned:=FALSE;
  459.     width:=mu.floor(animWidth*factor);
  460.     height:=mu.floor(animHeight*factor);
  461.     windowTags[winLeft].data:=(screen.width-width) DIV 2;
  462.     windowTags[winTop].data:=(screen.height-height) DIV 2;
  463.     windowTags[winWidth].data:=width;
  464.     windowTags[winHeight].data:=height;
  465.     windowTags[winTitle].data:=fileTitle;
  466.     windowTags[winMaxW].data:=animWidth*4;
  467.     windowTags[winMaxH].data:=animHeight*4;
  468.     windowTags[winMinW].data:=animWidth DIV 4;
  469.     windowTags[winMinH].data:=animHeight DIV 4;
  470.     i.ScreenToFront(screen);
  471.     RETURN g.noError;
  472.   END InitPubScreen;
  473. (* \\\ ------------------------------------------------------------------------- *)
  474.  
  475. (* /// ---------------------- "PROCEDURE InitOwnScreen()" ---------------------- *)
  476.   PROCEDURE InitOwnScreen(): LONGINT;
  477.  
  478.   VAR   screenTags: u.Tags12;
  479.         dispIDbyDim: LONGINT;
  480.         dispID: LONGINT;
  481.         dimInfo: gfx.DimensionInfo;
  482.         dispInfo: gfx.DisplayInfo;
  483.         nameInfo: gfx.NameInfo;
  484.         error: LONGINT;
  485.  
  486.   CONST scrID=0;
  487.         scrWidth=1;
  488.         scrHeight=2;
  489.         scrDepth=3;
  490.         scrColors=4;
  491.         scrErrorCode=5;
  492.         scrInterleaved=6;
  493.         winPointer=5;
  494.  
  495.   BEGIN
  496.     windowTags:=u.Tags20(i.waLeft,0,
  497.                          i.waTop,0,
  498.                          i.waWidth,0,
  499.                          i.waHeight,0,
  500.                          i.waCustomScreen,NIL,
  501.                          i.waPointer,NIL,
  502.                          i.waActivate,e.true,
  503.                          i.waAutoAdjust,e.true,
  504.                          i.waBorderless,e.true,
  505.                          i.waRMBTrap,e.true,
  506.                          i.waIDCMP,LONGSET{i.mouseButtons,i.vanillaKey,i.rawKey},
  507.                          u.done,0,
  508.                          0,0,
  509.                          0,0,
  510.                          0,0,
  511.                          0,0,
  512.                          0,0,
  513.                          0,0,
  514.                          0,0,
  515.                          0,0);
  516.     screenTags:=u.Tags12(i.saDisplayID,0,
  517.                          i.saWidth,0,
  518.                          i.saHeight,0,
  519.                          i.saDepth,0,
  520.                          i.saColors32,NIL,
  521.                          i.saErrorCode,NIL,
  522.                          i.saInterleaved,e.false,
  523.                          i.saTitle,y.ADR("CyberAVI"),
  524.                          i.saBehind,e.false,
  525.                          i.saQuiet,e.true,
  526.                          i.saPens,y.ADR("\x00\x00"
  527.                                         "\x00\x00"
  528.                                         "\x00\x00"
  529.                                         "\x00\x00"
  530.                                         "\x00\x00"
  531.                                         "\x00\x00"
  532.                                         "\x00\x00"
  533.                                         "\x00\x00"
  534.                                         "\x00\x00"
  535.                                         "\x00\x00"
  536.                                         "\x00\x00"
  537.                                         "\x00\x00"
  538.                                         "\xFF\xFF"),
  539.                          u.done,0);
  540.  
  541.     IF (animDepth>8) & (colorReduction OR ham8) THEN
  542.       animDepth:=8;
  543.       IF ham8 THEN
  544.         InitHAM8ColorMap();
  545.       ELSE
  546.         Init332ColorMap();
  547.       END;
  548.     END;
  549.  
  550.     IF (animDepth>8) & o.force24 THEN animDepth:=24; END;
  551.  
  552.     IF o.screenModeID#0 THEN
  553.       dispIDbyDim:=o.screenModeID;
  554.     ELSE
  555.       dispIDbyDim:=b.BestMode(animWidth,animHeight,animDepth,colorReduction,ham8);
  556.     END;
  557.     dispID:=dispIDbyDim;
  558. (* /// "$IF RUNDEBUG" *)
  559.     IF o.debug THEN
  560.        y.SETREG(0,gfx.GetDisplayInfoData(NIL,nameInfo,SIZE(nameInfo),gfx.dtagName,dispID));
  561.        d.PrintF("selected screenmode: %s ($%08lx)\n",y.ADR(nameInfo.name),dispID);
  562.     END;
  563. (* \\\ $END *)
  564.  
  565.     IF o.askScrMode OR (dispID=gfx.invalidID) THEN
  566. (* /// "$IF RUNDEBUG" *)
  567.       IF o.debug & (dispID=gfx.invalidID) THEN d.PrintF("invalid display id, prompting for screenmode\n"); END;
  568. (* \\\ "$END" *)
  569.       dispID:=b.SelectModeIDByReq(animWidth,animHeight,animDepth,dispIDbyDim,colorReduction,ham8);
  570.     END;
  571.  
  572.     IF dispID=gfx.invalidID THEN
  573.       IF dispIDbyDim=gfx.invalidID THEN
  574. (* /// "$IF RUNDEBUG" *)
  575.         IF o.debug THEN d.PrintF("invalid display id, selecting simple id\n"); END;
  576. (* \\\ "$END" *)
  577.         dispID:=b.SelectModeIDSimple(animWidth,animHeight,ham8);
  578.       ELSE
  579.         dispID:=dispIDbyDim;
  580.       END;
  581.     END;
  582.  
  583.     screenTags[scrID].data:=dispID;
  584.     IF colorReduction OR ham8 THEN
  585.       y.SETREG(0,gfx.GetDisplayInfoData(NIL,dimInfo,SIZE(dimInfo),gfx.dtagDims,dispID));
  586.       screenDepth:=dimInfo.maxDepth;
  587.       screenTags[scrWidth].data:=dimInfo.nominal.maxX-dimInfo.nominal.minX+1;
  588.       screenTags[scrHeight].data:=dimInfo.nominal.maxY-dimInfo.nominal.minY+1;
  589.       screenTags[scrDepth].data:=mu.max(animDepth,4); (* unter AGA besser minimale Plane-Anzahl nehmen... *)
  590.       screenTags[scrInterleaved].data:=e.true;
  591.     ELSE
  592.       screenDepth:=cgfx.GetCyberIDAttr(cgfx.idAttrDepth,dispID);
  593.       screenTags[scrWidth].data:=cgfx.GetCyberIDAttr(cgfx.idAttrWidth,dispID);
  594.       screenTags[scrHeight].data:=cgfx.GetCyberIDAttr(cgfx.idAttrHeight,dispID);
  595.       screenTags[scrDepth].data:=screenDepth; (* ... aber unter CyberGfx besser 8bpp *)
  596.     END;
  597.     screenTags[scrColors].data:=colorMap;
  598.     screenTags[scrErrorCode].data:=y.ADR(error);
  599.     screen:=i.OpenScreenTagListA(NIL,screenTags);
  600.     IF screen=NIL THEN
  601.       d.PrintF("Can't open screen: ");
  602.       CASE error OF
  603.       | i.osErrNoMem: d.PrintF("not enough memory\n");
  604.       | i.osErrNoChipMem: d.PrintF("not enough chip memory\n");
  605.       | i.osErrUnknownMode: d.PrintF("unknown display id $%08lx\n",dispID);
  606.       | i.oserrTooDeep: d.PrintF("depth %ld is too high\n",screenDepth);
  607.       | i.oserrNotAvailable: d.PrintF("mode $%08lx is not available\n",dispID);
  608.       ELSE
  609.         d.PrintF("unknown error\n");
  610.       END;
  611.       RETURN g.unknownError;
  612.     END;
  613.     y.SETREG(0,gfx.GetDisplayInfoData(NIL,dispInfo,SIZE(dispInfo),gfx.dtagDisp,dispID));
  614.     doubleScanned:=(gfx.isScandbl IN dispInfo.propertyFlags);
  615.     mouseBitMap:=gfx.AllocBitMap(16,1,2,LONGSET{gfx.bmbClear,gfx.bmbDisplayable},NIL); (* Pointer mit 16x1 Pixel und 2 Planes *)
  616.     IF mouseBitMap#NIL THEN
  617.       mouse:=i.NewObject(NIL,i.pointerClass,i.pointeraBitMap,mouseBitMap,
  618.                                             u.done);
  619.     ELSE
  620.       mouse:=NIL;
  621.     END;
  622.     windowTags[winWidth].data:=screen.width;
  623.     windowTags[winHeight].data:=screen.height;
  624.     windowTags[winScreen].data:=screen;
  625.     windowTags[winPointer].data:=mouse;
  626.     RETURN g.noError;
  627.   END InitOwnScreen;
  628. (* \\\ ------------------------------------------------------------------------- *)
  629.  
  630. BEGIN
  631.   doubleScanned:=TRUE;
  632.   IF virtual THEN RETURN g.noError; END;
  633.   errVal:=g.noError;
  634.   pubScreen:=(o.pubScreen#"");
  635.   cgx3:=e.OpenLibrary("cgxsystem.library",41);
  636.   IF pubScreen & (animDepth<=8) THEN
  637.     IF ~lv.CheckVersion(cgx3,41,9) THEN
  638.       pubScreen:=FALSE;
  639.       d.PrintF("Playback on public truecolor screens requires either truecolor animations (with\n"
  640.                "CyberGraphX V2), or CyberGraphX V3 (at least rev 41.9)!\n"
  641.                "Using own screen instead.\n");
  642.     END;
  643.   END;
  644.   IF cgx3#NIL THEN e.CloseLibrary(cgx3); END;
  645.   IF pubScreen THEN
  646.     IF InitPubScreen()#g.noError THEN
  647.       CloseDisplay();
  648.       pubScreen:=FALSE;
  649.       errVal:=InitOwnScreen();
  650.     END;
  651.   ELSE
  652.     errVal:=InitOwnScreen();
  653.   END;
  654.  
  655.   IF errVal=g.noError THEN
  656.     windowTags[winScreen].data:=screen;
  657.     window:=i.OpenWindowTagListA(NIL,windowTags);
  658.     IF window=NIL THEN
  659.       d.PrintF("Can't open window\n");
  660.       RETURN g.unknownError;
  661.     END;
  662.     rp:=window.rPort;
  663.     idcmpSig:=window.userPort.sigBit;
  664.     IF pubScreen THEN
  665.       leftOff:=window.borderLeft;
  666.       topOff:=window.borderTop;
  667.     ELSE
  668.       leftOff:=i.LongToUInt((window.width-animWidth) DIV 2);
  669.       topOff:=i.LongToUInt((window.height-animHeight) DIV 2);
  670.       IF screenDepth<15 THEN
  671.         gfx.SetRast(y.ADR(screen.rastPort),0);
  672.         gfx.SetRast(rp,0);
  673.       ELSE
  674.         y.SETREG(0,cgfx.FillPixelArray(y.ADR(screen.rastPort),0,0,screen.width,screen.height,0));
  675.         y.SETREG(0,cgfx.FillPixelArray(rp,0,0,window.width,window.height,0));
  676.       END;
  677.     END;
  678.  
  679.     IF screenDepth<15 THEN
  680.       IF colorReduction THEN
  681.         errVal:=InitTmpBitMap(); (* die AGA-Routine braucht eine extra BitMap *)
  682.       END;
  683.     END;
  684.   END;
  685.   RETURN errVal;
  686. END OpenDisplay;
  687. (* \\\ ------------------------------------------------------------------------- *)
  688.  
  689. (* /// ----------------------- "PROCEDURE DecodeDummy()" ----------------------- *)
  690. PROCEDURE DecodeDummy {"_DecodeDummy"} (from{8}: e.APTR;
  691.                                         to{9}: e.APTR;
  692.                                         width{0}: LONGINT;
  693.                                         height{1}: LONGINT;
  694.                                         encSize{2}: LONGINT;
  695.                                         spec{10}: e.APTR);
  696.  
  697. PROCEDURE SetupDummy(VAR codec: CodecHeader);
  698. BEGIN
  699.   decoderProc:=DecodeDummy;
  700.   decoderSpec:=NIL;
  701. END SetupDummy;
  702. (* \\\ ------------------------------------------------------------------------- *)
  703.  
  704. (* /// ---------------------------- "TYPE CVIDData" ---------------------------- *)
  705. TYPE    Color2x2Ptr=UNTRACED POINTER TO Color2x2;
  706.         Color2x2=STRUCT
  707.             r0,g0,b0: CHAR;
  708.             r1,g1,b1: CHAR;
  709.             r2,g2,b2: CHAR;
  710.             r3,g3,b3: CHAR;
  711.             clr00, clr01, clr02, clr03: LONGINT;
  712.             clr10, clr11, clr12, clr13: LONGINT;
  713.             clr20, clr21, clr22, clr23: LONGINT;
  714.             clr30, clr31, clr32, clr33: LONGINT;
  715.         END;
  716.         Color2x2ArrayPtr=UNTRACED POINTER TO Color2x2Array;
  717.         Color2x2Array=ARRAY 256 OF Color2x2;
  718.  
  719. CONST   cvidMaxStrips=16;
  720.  
  721. TYPE    CVIDDataPtr=UNTRACED POINTER TO CVIDData;
  722.         CVIDData=STRUCT
  723.             gray: BOOLEAN;
  724.             dither: BOOLEAN;
  725.             cvidMaps0: ARRAY cvidMaxStrips OF Color2x2ArrayPtr;
  726.             cvidMaps1: ARRAY cvidMaxStrips OF Color2x2ArrayPtr;
  727.             vMap0: ARRAY cvidMaxStrips OF LONGINT;
  728.             vMap1: ARRAY cvidMaxStrips OF LONGINT;
  729.             yuv: ys.YUVTablePtr;
  730.             limit: ys.RangeLimitPtr;
  731.             cmap: CMapArrPtr;
  732.         END;
  733.  
  734. VAR     cvidData: CVIDDataPtr;
  735. (* \\\ ------------------------------------------------------------------------- *)
  736.  
  737. (* /// ----------------------- "PROCEDURE DecodeCVID()" ------------------------ *)
  738. PROCEDURE DecodeCVID {"_DecodeCVID"} (from{8}: e.APTR;
  739.                                       to{9}: e.APTR;
  740.                                       width{0}: LONGINT;
  741.                                       height{1}: LONGINT;
  742.                                       encSize{2}: LONGINT;
  743.                                       spec{10}: e.APTR);
  744.  
  745. PROCEDURE SelectCVIDFuncs {"_SelectCVIDFuncs"} (spec{8}: CVIDDataPtr;
  746.                                                 reduce{0}: BOOLEAN;
  747.                                                 dither{1}: BOOLEAN);
  748.  
  749. PROCEDURE SetupCVID(codec: CodecHeader);
  750.  
  751. VAR     cnt: LONGINT;
  752.  
  753. BEGIN
  754.   IF cvidData=NIL THEN
  755.     NEW(cvidData);
  756.     FOR cnt:=0 TO cvidMaxStrips-1 DO
  757.       NEW(cvidData.cvidMaps0[cnt]);
  758.       NEW(cvidData.cvidMaps1[cnt]);
  759.     END;
  760.   END;
  761.   cvidData.gray:=grayScale;
  762.   cvidData.yuv:=ys.GenYUVTables();
  763.   cvidData.limit:=ys.InitLimitTables();
  764.   cvidData.cmap:=cmap;
  765.   SelectCVIDFuncs(cvidData,(colorReduction & ~ham8) OR grayScale,o.dither);
  766.   decoderProc:=DecodeCVID;
  767.   decoderSpec:=cvidData;
  768. END SetupCVID;
  769. (* \\\ ------------------------------------------------------------------------- *)
  770.  
  771. (* /// IV32
  772. (* /// ---------------------------- "TYPE IV32Data" ---------------------------- *)
  773. TYPE    IV32DataPtr=UNTRACED POINTER TO IV32Data;
  774.         IV32Data=STRUCT
  775.             gray: BOOLEAN;
  776.             dither: BOOLEAN;
  777.             yuv: ys.YUVTablePtr;
  778.             limit: ys.RangeLimitPtr;
  779.             cmap: CMapArrPtr;
  780.             x: UNTRACED POINTER TO ARRAY 10 OF LONGINT;
  781.         END;
  782.  
  783. VAR     iv32Data: IV32DataPtr;
  784. (* \\\ ------------------------------------------------------------------------- *)
  785.  
  786. (* /// ----------------------- "PROCEDURE DecodeIV32()" ------------------------ *)
  787. PROCEDURE DecodeIV32 {"_DecodeIV32"} (from{8}: e.APTR;
  788.                                       to{9}: e.APTR;
  789.                                       width{0}: LONGINT;
  790.                                       height{1}: LONGINT;
  791.                                       encSize{2}: LONGINT;
  792.                                       spec{10}: e.APTR);
  793.  
  794. PROCEDURE DecodeIV322 {"_DecodeIV32_2"} (from{8}: e.APTR;
  795.                                       to{9}: e.APTR;
  796.                                       width{0}: LONGINT;
  797.                                       height{1}: LONGINT;
  798.                                       encSize{2}: LONGINT;
  799.                                       spec{10}: e.APTR);
  800.  
  801. PROCEDURE SelectIV32Funcs {"_SelectIV32Funcs"} (spec{8}: IV32DataPtr;
  802.                                                 reduce{0}: BOOLEAN;
  803.                                                 dither{1}: BOOLEAN);
  804.  
  805. TYPE    arr256=UNTRACED POINTER TO ARRAY 256 OF LONGINT;
  806.  
  807. VAR     ivmem["L000126"]: e.LSTRPTR;
  808.         ivmemsize["L000127"]: LONGINT;
  809.         ivw["L000128"]: INTEGER;
  810.         ivh["L000129"]: INTEGER;
  811.         ivm1["_indeo_bufs"]: e.APTR;
  812.         ivm2["L000124"]: e.APTR;
  813.         ivm3["L000125"]: e.APTR;
  814.         ivm4["L00012A"]: e.APTR;
  815.         ivm5["L00012B"]: e.APTR;
  816.         ivm6["L00012C"]: e.APTR;
  817.         ibufinit["_indeo_buf_init"]: LONGINT;
  818.         iv12f["L00012F"]: e.APTR;
  819.         iv130["L000130"]: e.APTR;
  820.         iv131["L000131"]: e.APTR;
  821.         iv132["L000132"]: e.APTR;
  822.         iv133["L000133"]: e.APTR;
  823.  
  824.         yt["_YContrib"]: arr256;
  825.         ub["_UContribToB"]:arr256;
  826.         ug["_UContribToG"]:arr256;
  827.         vr["_VContribToG"]:arr256;
  828.         vg["_VContribToR"]:arr256;
  829.         indeoTabs["_indeo_tabs"]: LONGINT;
  830.  
  831. (* /// ----------------------- "PROCEDURE IndeoGenYUV()" ----------------------- *)
  832. PROCEDURE IndeoGenYUV();
  833.  
  834. VAR     i: LONGINT;
  835.         val: LONGINT;
  836.         x1,x2,x3,x4,x5: LONGINT;
  837.  
  838. BEGIN
  839.   NEW(yt); NEW(ub); NEW(ug); NEW(vr); NEW(vg);
  840.   val:=04563H;
  841.   FOR i:=127 TO 0 BY -1 DO
  842.     yt[i]:=val;
  843.     DEC(val,149);
  844.   END;
  845.   x3:=-13056;
  846.   x5:=6656;
  847.   x4:=6400;
  848.   x2:=-16640;
  849.   x1:=-16384;
  850.   FOR i:=0 TO 127 DO
  851.     ub[i]:=(x1 DIV 2)+(x2 DIV 2);
  852.     ug[i]:=x4 DIV 2;
  853.     vg[i]:=x5;
  854.     vr[i]:=x3;
  855.     INC(x3,204);
  856.     DEC(x5,104);
  857.     DEC(x4,100);
  858.     INC(x2,260);
  859.     INC(x1,256);
  860.   END;
  861.   FOR i:=0 TO 127 DO
  862.     yt[i+128]:=yt[i];
  863.     ub[i+128]:=ub[i];
  864.     ug[i+128]:=ug[i];
  865.     vg[i+128]:=vg[i];
  866.     vr[i+128]:=vr[i];
  867.   END;
  868.   indeoTabs:=000000080H;
  869.   iv12f:=yt;
  870.   iv130:=ub;
  871.   iv131:=vr;
  872.   iv132:=ug;
  873.   iv133:=vg;
  874. END IndeoGenYUV;
  875. (* \\\ ------------------------------------------------------------------------- *)
  876.  
  877. (* /// -------------------- "PROCEDURE IndeoInitYUVBufs()" --------------------- *)
  878. PROCEDURE IndeoInitYUVBufs(width: LONGINT;
  879.                            height: LONGINT);
  880. VAR     w16: LONGINT;
  881.         h16: LONGINT;
  882.         w164: LONGINT;
  883.         cnt: LONGINT;
  884.         ptr: e.LSTRPTR;
  885.  
  886. BEGIN
  887.   w16:=i2m.Round(width,16);
  888.   h16:=i2m.Round(height,16);
  889.   ivmemsize:=2*w16*h16+4*w16;
  890.   ol.New(ivmem,ivmemsize);
  891.   w164:=w16 DIV 4;
  892.   ivw:=i.LongToUInt(w16);
  893.   ivh:=i.LongToUInt(h16);
  894.   ivm1:=y.VAL(e.LSTRPTR,y.VAL(LONGINT,ivmem)+w16);
  895.   ivm4:=y.VAL(e.LSTRPTR,y.VAL(LONGINT,ivmem)+ivmemsize DIV 2);
  896.  
  897.   ivm2:=y.VAL(e.LSTRPTR,y.VAL(LONGINT,ivmem)+ivmemsize-w164*4);
  898.   ivm3:=y.VAL(e.LSTRPTR,y.VAL(LONGINT,ivmem)+ivmemsize-w164*2);
  899.  
  900.   ivm5:=y.VAL(e.LSTRPTR,y.VAL(LONGINT,ivmem)+ivmemsize-w164*3);
  901.   ivm6:=y.VAL(e.LSTRPTR,y.VAL(LONGINT,ivmem)+ivmemsize-w164*1);
  902.   ptr:=ivmem;
  903.   FOR cnt:=0 TO w16-1 DO ptr[cnt]:=40X; END;
  904.   ptr:=y.VAL(e.LSTRPTR,y.VAL(LONGINT,ivmem)+ivmemsize DIV 2-w16);
  905.   FOR cnt:=0 TO w16-1 DO ptr[cnt]:=40X; END;
  906.   ptr:=y.VAL(e.LSTRPTR,y.VAL(LONGINT,ivmem)+ivmemsize-w16*2);
  907.   FOR cnt:=0 TO w16*2-1 DO ptr[cnt]:=40X; END;
  908.   ibufinit:=1;
  909.   (* d.PrintF("%ld x %ld, %08lx, %ld\n",ivw,ivh,ivmem,ivmemsize); *)
  910. END IndeoInitYUVBufs;
  911. (* \\\ ------------------------------------------------------------------------- *)
  912.  
  913. (* ///
  914. PROCEDURE myentry{"myentry"}(w{0}: LONGINT; h{1}: LONGINT);
  915. PROCEDURE myfree{"myfree"}(x{8}: e.APTR);
  916. \\\ *)
  917.  
  918. PROCEDURE SetupIV32(codec: CodecHeader);
  919. BEGIN
  920.   IF iv32Data=NIL THEN NEW(iv32Data); END;
  921.   iv32Data.gray:=grayScale;
  922.   iv32Data.yuv:=ys.GenYUVTables();
  923.   iv32Data.limit:=ys.InitLimitTables();
  924.   iv32Data.cmap:=cmap;
  925.   NEW(iv32Data.x);
  926. (* ///
  927.   d.PrintF("mem: %08lx\n"
  928.            "size: %ld\n"
  929.            "width: %ld\n"
  930.            "height: %ld\n"
  931.            "bufs: %08lx\n"
  932.            "124: %08lx\n"
  933.            "125: %08lx\n"
  934.            "12a: %08lx\n"
  935.            "12b: %08lx\n"
  936.            "12c: %08lx\n"
  937.            "init: %ld\n\n"
  938.            ,ivmem,ivmemsize,ivw,ivh,ivm1,ivm2,ivm3,ivm4,ivm5,ivm6,ibufinit);
  939. \\\ *)
  940.   IndeoGenYUV();
  941.   IndeoInitYUVBufs(codec.width,codec.height);
  942. (* ///
  943.   myentry(codec.width,codec.height);
  944.   d.PrintF("mem: %08lx\n"
  945.            "size: %ld\n"
  946.            "width: %ld\n"
  947.            "height: %ld\n"
  948.            "bufs: %08lx\n"
  949.            "124: %08lx\n"
  950.            "125: %08lx\n"
  951.            "12a: %08lx\n"
  952.            "12b: %08lx\n"
  953.            "12c: %08lx\n"
  954.            "init: %ld\n\n"
  955.            ,ivmem,ivmemsize,ivw,ivh,ivm1,ivm2,ivm3,ivm4,ivm5,ivm6,ibufinit);
  956. \\\ *)
  957. (* ///
  958.   fh:=d.Open("sd0:memdump2",d.newFile);
  959.   y.SETREG(0,d.Write(fh,ivmem^,ivmemsize));
  960.   d.OldClose(fh);
  961. \\\ *)
  962. (* ///
  963.   IF ivmem#NIL THEN myfree(ivmem); END;
  964. \\\ *)
  965.   SelectIV32Funcs(iv32Data,(colorReduction & ~ham8) OR grayScale,o.dither);
  966.   decoderProc:=DecodeIV322;
  967.   decoderSpec:=iv32Data;
  968. END SetupIV32;
  969. (* \\\ ------------------------------------------------------------------------- *)
  970. \\\ *)
  971.  
  972. (* /// ---------------------------- "TYPE JPEGData" ---------------------------- *)
  973. TYPE    JPEGDataPtr=UNTRACED POINTER TO JPEGData;
  974.         JPEGData=STRUCT
  975.             gray: BOOLEAN;
  976.             dither: BOOLEAN;
  977.             yuvTab: ys.YUVTablePtr;
  978.             yuvBuf: ys.YUVBufferPtr;
  979.             limit: ys.RangeLimitPtr;
  980.             quantTab: ARRAY 4 OF e.APTR;
  981.             cmap: CMapArrPtr;
  982.         END;
  983.  
  984. VAR     jpegData: JPEGDataPtr;
  985. (* \\\ ------------------------------------------------------------------------- *)
  986.  
  987. (* /// ----------------------- "PROCEDURE DecodeJPEG()" ------------------------ *)
  988. PROCEDURE DecodeJPEG {"_DecodeJPEG"} (from{8}: e.APTR;
  989.                                       to{9}: e.APTR;
  990.                                       width{0}: LONGINT;
  991.                                       height{1}: LONGINT;
  992.                                       encSize{2}: LONGINT;
  993.                                       spec{10}: e.APTR);
  994.  
  995. PROCEDURE SelectJPEGFuncs {"_SelectJPEGFuncs"} (spec{8}: JPEGDataPtr;
  996.                                                 reduce{0}: BOOLEAN;
  997.                                                 dither{1}: BOOLEAN);
  998.  
  999. PROCEDURE SetupJPEG(VAR codec: CodecHeader);
  1000.  
  1001. VAR     cnt: LONGINT;
  1002.  
  1003. BEGIN
  1004.   IF jpegData=NIL THEN
  1005.     NEW(jpegData);
  1006.     FOR cnt:=0 TO 3 DO ol.New(jpegData.quantTab[cnt],64*SIZE(LONGINT)); END;
  1007.   END;
  1008.   jpegData.gray:=grayScale;
  1009.   jpegData.yuvTab:=ys.GenYUVTables();
  1010.   jpegData.yuvBuf:=ys.AllocMCUBuffers(codec.width,codec.height);
  1011.   jpegData.limit:=ys.InitLimitTables();
  1012.   jpegData.cmap:=cmap;
  1013.   SelectJPEGFuncs(jpegData,(colorReduction & ~ham8) OR grayScale,o.dither);
  1014.   decoderProc:=DecodeJPEG;
  1015.   decoderSpec:=jpegData;
  1016. END SetupJPEG;
  1017. (* \\\ ------------------------------------------------------------------------- *)
  1018.  
  1019. (* /// ---------------------------- "TYPE MSVCData" ---------------------------- *)
  1020. TYPE    MSVCDataPtr=UNTRACED POINTER TO MSVCData;
  1021.         MSVCData=STRUCT
  1022.             gray: BOOLEAN;
  1023.             limit: ys.RangeLimitPtr;
  1024.             cmap: CMapArrPtr;
  1025.         END;
  1026.  
  1027. VAR     msvcData: MSVCDataPtr;
  1028. (* \\\ ------------------------------------------------------------------------- *)
  1029.  
  1030. (* /// ----------------------- "PROCEDURE DecodeMSVC8()" ----------------------- *)
  1031. PROCEDURE DecodeMSVC8 {"_DecodeMSVC8"} (from{8}: e.APTR;
  1032.                                         to{9}: e.APTR;
  1033.                                         width{0}: LONGINT;
  1034.                                         height{1}: LONGINT;
  1035.                                         encSize{2}: LONGINT;
  1036.                                         spec{10}: e.APTR);
  1037.  
  1038. PROCEDURE SetupMSVC8(codec: CodecHeader);
  1039. BEGIN
  1040.   decoderProc:=DecodeMSVC8;
  1041.   decoderSpec:=NIL;
  1042. END SetupMSVC8;
  1043. (* \\\ ------------------------------------------------------------------------- *)
  1044.  
  1045. (* /// ---------------------- "PROCEDURE DecodeMSVC16()" ----------------------- *)
  1046. PROCEDURE DecodeMSVC16toRGB {"_DecodeMSVC16toRGB"} (from{8}: e.APTR;
  1047.                                                     to{9}: e.APTR;
  1048.                                                     width{0}: LONGINT;
  1049.                                                     height{1}: LONGINT;
  1050.                                                     encSize{2}: LONGINT;
  1051.                                                     spec{10}: e.APTR);
  1052.  
  1053. PROCEDURE DecodeMSVC16to332 {"_DecodeMSVC16to332"} (from{8}: e.APTR;
  1054.                                                      to{9}: e.APTR;
  1055.                                                      width{0}: LONGINT;
  1056.                                                      height{1}: LONGINT;
  1057.                                                      encSize{2}: LONGINT;
  1058.                                                      spec{10}: e.APTR);
  1059.  
  1060. PROCEDURE DecodeMSVC16to332Dith {"_DecodeMSVC16to332Dith"} (from{8}: e.APTR;
  1061.                                                             to{9}: e.APTR;
  1062.                                                             width{0}: LONGINT;
  1063.                                                             height{1}: LONGINT;
  1064.                                                             encSize{2}: LONGINT;
  1065.                                                             spec{10}: e.APTR);
  1066.  
  1067. PROCEDURE SetupMSVC16(codec: CodecHeader);
  1068. BEGIN
  1069.   IF msvcData=NIL THEN NEW(msvcData); END;
  1070.   msvcData.gray:=grayScale;
  1071.   IF (colorReduction & ~ham8 & ~o.dither) OR grayScale THEN
  1072.     decoderProc:=DecodeMSVC16to332;
  1073.   ELSE
  1074.     IF o.dither THEN
  1075.       msvcData.limit:=ys.InitLimitTables();
  1076.       msvcData.cmap:=cmap;
  1077.       decoderProc:=DecodeMSVC16to332Dith;
  1078.     ELSE
  1079.       decoderProc:=DecodeMSVC16toRGB;
  1080.     END;
  1081.   END;
  1082.   decoderSpec:=msvcData;
  1083. END SetupMSVC16;
  1084. (* \\\ ------------------------------------------------------------------------- *)
  1085.  
  1086. (* /// ---------------------------- "TYPE RGBData" ----------------------------- *)
  1087. TYPE    RGBDataPtr=UNTRACED POINTER TO RGBData;
  1088.         RGBData=STRUCT
  1089.             gray: BOOLEAN;
  1090.             limit: ys.RangeLimitPtr;
  1091.             cmap: CMapArrPtr;
  1092.         END;
  1093.  
  1094. VAR     rgbData: RGBDataPtr;
  1095. (* \\\ ------------------------------------------------------------------------- *)
  1096.  
  1097. (* /// ----------------------- "PROCEDURE DecodeRGB4()" ------------------------ *)
  1098. PROCEDURE DecodeRGB4 {"_DecodeRGB4"} (from{8}: e.APTR;
  1099.                                       to{9}: e.APTR;
  1100.                                       width{0}: LONGINT;
  1101.                                       height{1}: LONGINT;
  1102.                                       encSize{2}: LONGINT;
  1103.                                       spec{10}: e.APTR);
  1104.  
  1105. PROCEDURE SetupRGB4(codec: CodecHeader);
  1106. BEGIN
  1107.   decoderProc:=DecodeRGB4;
  1108.   decoderSpec:=NIL;
  1109. END SetupRGB4;
  1110. (* \\\ ------------------------------------------------------------------------- *)
  1111.  
  1112. (* /// ----------------------- "PROCEDURE DecodeRGB8()" ------------------------ *)
  1113. PROCEDURE DecodeRGB8 {"_DecodeRGB8"} (from{8}: e.APTR;
  1114.                                       to{9}: e.APTR;
  1115.                                       width{0}: LONGINT;
  1116.                                       height{1}: LONGINT;
  1117.                                       encSize{2}: LONGINT;
  1118.                                       spec{10}: e.APTR);
  1119.  
  1120. PROCEDURE SetupRGB8(codec: CodecHeader);
  1121. BEGIN
  1122.   decoderProc:=DecodeRGB8;
  1123.   decoderSpec:=NIL;
  1124. END SetupRGB8;
  1125. (* \\\ ------------------------------------------------------------------------- *)
  1126.  
  1127. (* /// ----------------------- "PROCEDURE DecodeRGB16()" ----------------------- *)
  1128. PROCEDURE DecodeRGB16toRGB {"_DecodeRGB16toRGB"} (from{8}: e.APTR;
  1129.                                                   to{9}: e.APTR;
  1130.                                                   width{0}: LONGINT;
  1131.                                                   height{1}: LONGINT;
  1132.                                                   encSize{2}: LONGINT;
  1133.                                                   spec{10}: e.APTR);
  1134.  
  1135. PROCEDURE DecodeRGB16to332 {"_DecodeRGB16to332"} (from{8}: e.APTR;
  1136.                                                   to{9}: e.APTR;
  1137.                                                   width{0}: LONGINT;
  1138.                                                   height{1}: LONGINT;
  1139.                                                   encSize{2}: LONGINT;
  1140.                                                   spec{10}: e.APTR);
  1141.  
  1142. PROCEDURE DecodeRGB16to332Dith {"_DecodeRGB16to332Dith"} (from{8}: e.APTR;
  1143.                                                           to{9}: e.APTR;
  1144.                                                           width{0}: LONGINT;
  1145.                                                           height{1}: LONGINT;
  1146.                                                           encSize{2}: LONGINT;
  1147.                                                           spec{10}: e.APTR);
  1148.  
  1149. PROCEDURE SetupRGB16(codec: CodecHeader);
  1150. BEGIN
  1151.   IF rgbData=NIL THEN NEW(rgbData); END;
  1152.   rgbData.gray:=grayScale;
  1153.   IF (colorReduction & ~ham8 & ~o.dither) OR grayScale THEN
  1154.     decoderProc:=DecodeRGB16to332;
  1155.   ELSE
  1156.     IF o.dither THEN
  1157.       rgbData.limit:=ys.InitLimitTables();
  1158.       rgbData.cmap:=cmap;
  1159.       decoderProc:=DecodeRGB16to332Dith;
  1160.     ELSE
  1161.       decoderProc:=DecodeRGB16toRGB;
  1162.     END;
  1163.   END;
  1164.   decoderSpec:=rgbData;
  1165. END SetupRGB16;
  1166. (* \\\ ------------------------------------------------------------------------- *)
  1167.  
  1168. (* /// ----------------------- "PROCEDURE DecodeRGB24()" ----------------------- *)
  1169. PROCEDURE DecodeRGB24toRGB {"_DecodeRGB24toRGB"} (from{8}: e.APTR;
  1170.                                                   to{9}: e.APTR;
  1171.                                                   width{0}: LONGINT;
  1172.                                                   height{1}: LONGINT;
  1173.                                                   encSize{2}: LONGINT;
  1174.                                                   spec{10}: e.APTR);
  1175.  
  1176. PROCEDURE DecodeRGB24to332 {"_DecodeRGB24to332"} (from{8}: e.APTR;
  1177.                                                   to{9}: e.APTR;
  1178.                                                   width{0}: LONGINT;
  1179.                                                   height{1}: LONGINT;
  1180.                                                   encSize{2}: LONGINT;
  1181.                                                   spec{10}: e.APTR);
  1182.  
  1183. PROCEDURE DecodeRGB24to332Dith {"_DecodeRGB24to332Dith"} (from{8}: e.APTR;
  1184.                                                           to{9}: e.APTR;
  1185.                                                           width{0}: LONGINT;
  1186.                                                           height{1}: LONGINT;
  1187.                                                           encSize{2}: LONGINT;
  1188.                                                           spec{10}: e.APTR);
  1189.  
  1190. PROCEDURE SetupRGB24(codec: CodecHeader);
  1191. BEGIN
  1192.   IF rgbData=NIL THEN NEW(rgbData); END;
  1193.   rgbData.gray:=grayScale;
  1194.   IF (colorReduction & ~ham8 & ~o.dither) OR grayScale THEN
  1195.     decoderProc:=DecodeRGB24to332;
  1196.   ELSE
  1197.     IF o.dither THEN
  1198.       rgbData.limit:=ys.InitLimitTables();
  1199.       rgbData.cmap:=cmap;
  1200.       decoderProc:=DecodeRGB24to332Dith;
  1201.     ELSE
  1202.       decoderProc:=DecodeRGB24toRGB;
  1203.     END;
  1204.   END;
  1205.   decoderSpec:=rgbData;
  1206. END SetupRGB24;
  1207. (* \\\ ------------------------------------------------------------------------- *)
  1208.  
  1209. (* /// ----------------------- "PROCEDURE DecodeRGB32()" ----------------------- *)
  1210. PROCEDURE DecodeRGB32toRGB {"_DecodeRGB32toRGB"} (from{8}: e.APTR;
  1211.                                                   to{9}: e.APTR;
  1212.                                                   width{0}: LONGINT;
  1213.                                                   height{1}: LONGINT;
  1214.                                                   encSize{2}: LONGINT;
  1215.                                                   spec{10}: e.APTR);
  1216.  
  1217. PROCEDURE DecodeRGB32to332 {"_DecodeRGB32to332"} (from{8}: e.APTR;
  1218.                                                   to{9}: e.APTR;
  1219.                                                   width{0}: LONGINT;
  1220.                                                   height{1}: LONGINT;
  1221.                                                   encSize{2}: LONGINT;
  1222.                                                   spec{10}: e.APTR);
  1223.  
  1224. PROCEDURE DecodeRGB32to332Dith {"_DecodeRGB32to332Dith"} (from{8}: e.APTR;
  1225.                                                           to{9}: e.APTR;
  1226.                                                           width{0}: LONGINT;
  1227.                                                           height{1}: LONGINT;
  1228.                                                           encSize{2}: LONGINT;
  1229.                                                           spec{10}: e.APTR);
  1230.  
  1231. PROCEDURE SetupRGB32(codec: CodecHeader);
  1232. BEGIN
  1233.   IF rgbData=NIL THEN NEW(rgbData); END;
  1234.   rgbData.gray:=grayScale;
  1235.   IF (colorReduction & ~ham8 & ~o.dither) OR grayScale THEN
  1236.     decoderProc:=DecodeRGB32to332;
  1237.   ELSE
  1238.     IF o.dither THEN
  1239.       rgbData.limit:=ys.InitLimitTables();
  1240.       rgbData.cmap:=cmap;
  1241.       decoderProc:=DecodeRGB32to332Dith;
  1242.     ELSE
  1243.       decoderProc:=DecodeRGB32toRGB;
  1244.     END;
  1245.   END;
  1246.   decoderSpec:=rgbData;
  1247. END SetupRGB32;
  1248. (* \\\ ------------------------------------------------------------------------- *)
  1249.  
  1250. (* /// ----------------------- "PROCEDURE DecodeRLE8()" ------------------------ *)
  1251. PROCEDURE DecodeRLE8 {"_DecodeRLE8"} (from{8}: e.APTR;
  1252.                                       to{9}: e.APTR;
  1253.                                       width{0}: LONGINT;
  1254.                                       height{1}: LONGINT;
  1255.                                       encSize{2}: LONGINT;
  1256.                                       spec{10}: e.APTR);
  1257.  
  1258. PROCEDURE SetupRLE8(codec: CodecHeader);
  1259. BEGIN
  1260.   decoderProc:=DecodeRLE8;
  1261.   decoderSpec:=NIL;
  1262. END SetupRLE8;
  1263. (* \\\ ------------------------------------------------------------------------- *)
  1264.  
  1265. (* /// ---------------------------- "TYPE ULTIData" ---------------------------- *)
  1266. TYPE    LONGPTR=UNTRACED POINTER TO ARRAY MAX(INTEGER) OF LONGINT;
  1267.  
  1268.         LTCTabPtr=UNTRACED POINTER TO ARRAY 16384 OF CHAR;
  1269.  
  1270.         ULTIDataPtr=UNTRACED POINTER TO ULTIData;
  1271.         ULTIData=STRUCT
  1272.             gray: BOOLEAN;
  1273.             ltcTab: LTCTabPtr;
  1274.             cr: ARRAY 16 OF LONGINT;
  1275.             cb: ARRAY 16 OF LONGINT;
  1276.             crcb: ARRAY 256 OF LONGINT;
  1277.             limit: ys.RangeLimitPtr;
  1278.             cmap: CMapArrPtr;
  1279.         END;
  1280.  
  1281. VAR     ultiData: ULTIDataPtr;
  1282. (* \\\ ------------------------------------------------------------------------- *)
  1283.  
  1284. (* /// ----------------------- "PROCEDURE DecodeULTI()" ------------------------ *)
  1285. PROCEDURE DecodeULTItoRGB {"_DecodeULTItoRGB"} (from{8}: e.APTR;
  1286.                                                 to{9}: e.APTR;
  1287.                                                 width{0}: LONGINT;
  1288.                                                 height{1}: LONGINT;
  1289.                                                 encSize{2}: LONGINT;
  1290.                                                 spec{10}: e.APTR);
  1291.  
  1292. PROCEDURE DecodeULTIto332 {"_DecodeULTIto332"} (from{8}: e.APTR;
  1293.                                                 to{9}: e.APTR;
  1294.                                                 width{0}: LONGINT;
  1295.                                                 height{1}: LONGINT;
  1296.                                                 encSize{2}: LONGINT;
  1297.                                                 spec{10}: e.APTR);
  1298.  
  1299. PROCEDURE DecodeULTIto332Dith {"_DecodeULTIto332Dith"} (from{8}: e.APTR;
  1300.                                                         to{9}: e.APTR;
  1301.                                                         width{0}: LONGINT;
  1302.                                                         height{1}: LONGINT;
  1303.                                                         encSize{2}: LONGINT;
  1304.                                                         spec{10}: e.APTR);
  1305.  
  1306. PROCEDURE GenUltiLTC();
  1307.  
  1308. TYPE    arr=ARRAY 20 OF LONGINT;
  1309.  
  1310.   PROCEDURE check(val: LONGINT; a: arr): BOOLEAN;
  1311.   VAR   x: INTEGER;
  1312.   BEGIN
  1313.     x:=0;
  1314.     WHILE a[x]#255 DO
  1315.       IF a[x]=val THEN RETURN TRUE; END;
  1316.       INC(x);
  1317.     END;
  1318.     RETURN FALSE;
  1319.   END check;
  1320.  
  1321. CONST   lin=arr( 2, 3, 5, 6, 7, 8,11,14,17,20,255,255,255,255,255,255,255,255,255,255);
  1322.         lo=arr(  4, 5, 6, 7, 8,11,14,17,20,23, 26, 29, 32, 36,255,255,255,255,255,255);
  1323.         hi=arr(  6, 8,11,14,17,20,23,26,29,32, 35, 40, 46,255,255,255,255,255,255,255);
  1324.  
  1325. VAR     ys: LONGINT;
  1326.         ye: LONGINT;
  1327.         ydelta: LONGINT;
  1328.         x: LONGINT;
  1329.         yinc: LONGINT;
  1330.         y1,y2: LONGINT;
  1331.         yd: e.FLOAT;
  1332.         tab: LTCTabPtr;
  1333.  
  1334. BEGIN
  1335.   x:=0;
  1336.   tab:=ultiData.ltcTab;
  1337.   FOR ys:=0 TO 63 DO
  1338.     FOR ye:=ys TO 63 DO
  1339.       ydelta:=ye-ys;
  1340.       IF check(ydelta,lin) THEN
  1341.         yinc:=(ydelta+1) DIV 3;
  1342.         tab[x]:=CHR(ys); tab[x+1]:=CHR(ys+yinc); tab[x+2]:=CHR(ye-yinc); tab[x+3]:=CHR(ye); INC(x,4);
  1343.       END;
  1344.       IF check(ydelta,lo) THEN
  1345.         yd:=ydelta;
  1346.         y1:=ye-ENTIER(((2*yd-5.0)/10.0));
  1347.         y2:=ye-ENTIER(((  yd-5.0)/10.0));
  1348.         tab[x]:=CHR(ys); tab[x+1]:=CHR(y1); tab[x+2]:=CHR(y2); tab[x+3]:=CHR(ye); INC(x,4);
  1349.         y2:=ys+ENTIER(((2*yd+5.0)/10.0));
  1350.         tab[x]:=CHR(ys); tab[x+1]:=CHR(y2); tab[x+2]:=CHR(y1); tab[x+3]:=CHR(ye); INC(x,4);
  1351.         y1:=ys+ENTIER(((  yd+5.0)/10.0));
  1352.         tab[x]:=CHR(ys); tab[x+1]:=CHR(y1); tab[x+2]:=CHR(y2); tab[x+3]:=CHR(ye); INC(x,4);
  1353.       END;
  1354.       IF check(ydelta,hi) THEN
  1355.         tab[x]:=CHR(ys); tab[x+1]:=CHR(ye); tab[x+2]:=CHR(ye); tab[x+3]:=CHR(ye); INC(x,4);
  1356.         tab[x]:=CHR(ys); tab[x+1]:=CHR(ys); tab[x+2]:=CHR(ye); tab[x+3]:=CHR(ye); INC(x,4);
  1357.         tab[x]:=CHR(ys); tab[x+1]:=CHR(ys); tab[x+2]:=CHR(ys); tab[x+3]:=CHR(ye); INC(x,4);
  1358.       END;
  1359.     END;
  1360.   END;
  1361. END GenUltiLTC;
  1362.  
  1363. PROCEDURE GenUltiYUV();
  1364.  
  1365. VAR     rt: e.FLOAT;
  1366.         bt: e.FLOAT;
  1367.         cnt: INTEGER;
  1368.         r: e.FLOAT;
  1369.         b: e.FLOAT;
  1370.         tmp: INTEGER;
  1371.         str: e.STRING;
  1372.  
  1373. BEGIN
  1374.   rt:=16384.0*1.40200;
  1375.   bt:=16384.0*1.77200;
  1376.   FOR cnt:=0 TO 15 DO
  1377.     r:=63.0*((cnt-5.0)/40.0);
  1378.     b:=63.0*((cnt-6.0)/34.0);
  1379.     ultiData.cr[cnt]:=ENTIER(rt*r);
  1380.     ultiData.cb[cnt]:=ENTIER(bt*b);
  1381.   END;
  1382.   rt:=16384.0*(-0.71414);
  1383.   bt:=16384.0*(-0.34414);
  1384.   FOR cnt:=0 TO 255 DO
  1385.     tmp:=cnt MOD 16;
  1386.     r:=63.0*((tmp-5.0)/40.0);
  1387.     tmp:=(cnt DIV 16) MOD 16;
  1388.     b:=63.0*((tmp-6.0)/34.0);
  1389.     ultiData.crcb[cnt]:=ENTIER(bt*b+rt*r);
  1390.   END;
  1391. END GenUltiYUV;
  1392.  
  1393. PROCEDURE SetupULTI(codec: CodecHeader);
  1394. BEGIN
  1395.   IF ultiData=NIL THEN
  1396.     NEW(ultiData);
  1397.     NEW(ultiData.ltcTab);
  1398.     GenUltiLTC();
  1399.     GenUltiYUV();
  1400.   END;
  1401.   ultiData.gray:=grayScale;
  1402.   IF (colorReduction & ~ham8 & ~o.dither) OR grayScale THEN
  1403.     decoderProc:=DecodeULTIto332;
  1404.   ELSE
  1405.     IF o.dither THEN
  1406.       ultiData.limit:=ys.InitLimitTables();
  1407.       ultiData.cmap:=cmap;
  1408.       decoderProc:=DecodeULTIto332Dith;
  1409.     ELSE
  1410.       decoderProc:=DecodeULTItoRGB;
  1411.     END;
  1412.   END;
  1413.   decoderSpec:=ultiData;
  1414. END SetupULTI;
  1415. (* \\\ ------------------------------------------------------------------------- *)
  1416.  
  1417. (* /// ---------------------------- "TYPE YUV2Data" ---------------------------- *)
  1418. TYPE    YUV2DataPtr=UNTRACED POINTER TO YUV2Data;
  1419.         YUV2Data=STRUCT
  1420.             gray: BOOLEAN;
  1421.             yuvTab: ys.YUVTablePtr;
  1422.             yuvBuf: ys.YUVBufferPtr;
  1423.             limit: ys.RangeLimitPtr;
  1424.             cmap: CMapArrPtr;
  1425.         END;
  1426.  
  1427. VAR     yuv2Data: YUV2DataPtr;
  1428. (* \\\ ------------------------------------------------------------------------- *)
  1429.  
  1430. (* /// ----------------------- "PROCEDURE DecodeYUV2()" ------------------------ *)
  1431. PROCEDURE DecodeYUV2A {"_DecodeYUV2A"} (from{8}: e.APTR;
  1432.                                         to{9}: e.APTR;
  1433.                                         width{0}: LONGINT;
  1434.                                         height{1}: LONGINT;
  1435.                                         encSize{2}: LONGINT;
  1436.                                         spec{10}: e.APTR);
  1437.  
  1438. PROCEDURE DecodeYUV2B {"_DecodeYUV2B"} (from{8}: e.APTR;
  1439.                                         to{9}: e.APTR;
  1440.                                         width{0}: LONGINT;
  1441.                                         height{1}: LONGINT;
  1442.                                         encSize{2}: LONGINT;
  1443.                                         spec{10}: e.APTR);
  1444.  
  1445. PROCEDURE SelectYUV2Funcs {"_SelectYUV2Funcs"} (spec{8}: YUV2DataPtr;
  1446.                                                 reduce{0}: BOOLEAN;
  1447.                                                 dither{1}: BOOLEAN);
  1448.  
  1449. PROCEDURE SetupYUV2(codec: CodecHeader);
  1450. BEGIN
  1451.   IF yuv2Data=NIL THEN NEW(yuv2Data); END;
  1452.   yuv2Data.gray:=grayScale;
  1453.   yuv2Data.yuvTab:=ys.GenYUVTables();
  1454.   yuv2Data.yuvBuf:=ys.AllocMCUBuffers(codec.width,codec.height);
  1455.   yuv2Data.limit:=ys.InitLimitTables();
  1456.   yuv2Data.cmap:=cmap;
  1457.   SelectYUV2Funcs(yuv2Data,(colorReduction & ~ham8) OR grayScale,o.dither);
  1458.   IF codec.compression=idYUV2 THEN
  1459.     decoderProc:=DecodeYUV2A;
  1460.   ELSE
  1461.     decoderProc:=DecodeYUV2B;
  1462.   END;
  1463.   decoderSpec:=yuv2Data;
  1464. END SetupYUV2;
  1465. (* \\\ ------------------------------------------------------------------------- *)
  1466.  
  1467. (* /// ---------------------------- "TYPE YUV9Data" ---------------------------- *)
  1468. TYPE    YUV9DataPtr=UNTRACED POINTER TO YUV9Data;
  1469.         YUV9Data=STRUCT
  1470.             gray: BOOLEAN;
  1471.             yuvTab: ys.YUVTablePtr;
  1472.             limit: ys.RangeLimitPtr;
  1473.             cmap: CMapArrPtr;
  1474.         END;
  1475.  
  1476. VAR     yuv9Data: YUV9DataPtr;
  1477. (* \\\ ------------------------------------------------------------------------- *)
  1478.  
  1479. (* /// ----------------------- "PROCEDURE DecodeYUV9()" ------------------------ *)
  1480. PROCEDURE DecodeYUV9 {"_DecodeYUV9"} (from{8}: e.APTR;
  1481.                                       to{9}: e.APTR;
  1482.                                       width{0}: LONGINT;
  1483.                                       height{1}: LONGINT;
  1484.                                       encSize{2}: LONGINT;
  1485.                                       spec{10}: e.APTR);
  1486.  
  1487. PROCEDURE SelectYUV9Funcs {"_SelectYUV9Funcs"} (spec{8}: YUV9DataPtr;
  1488.                                                 reduce{0}: BOOLEAN;
  1489.                                                 dither{1}: BOOLEAN);
  1490.  
  1491. PROCEDURE SetupYUV9(codec: CodecHeader);
  1492. BEGIN
  1493.   IF yuv9Data=NIL THEN NEW(yuv9Data); END;
  1494.   yuv9Data.gray:=grayScale;
  1495.   yuv9Data.yuvTab:=ys.GenYUVTables();
  1496.   yuv9Data.limit:=ys.InitLimitTables();
  1497.   yuv9Data.cmap:=cmap;
  1498.   SelectYUV9Funcs(yuv9Data,(colorReduction & ~ham8) OR grayScale,o.dither);
  1499.   decoderProc:=DecodeYUV9;
  1500.   decoderSpec:=yuv9Data;
  1501. END SetupYUV9;
  1502. (* \\\ ------------------------------------------------------------------------- *)
  1503.  
  1504. (* /// ---------------------------- "TYPE YV12Data" ---------------------------- *)
  1505. TYPE    YV12DataPtr=UNTRACED POINTER TO YV12Data;
  1506.         YV12Data=STRUCT
  1507.             gray: BOOLEAN;
  1508.             yuvTab: ys.YUVTablePtr;
  1509.             limit: ys.RangeLimitPtr;
  1510.             cmap: CMapArrPtr;
  1511.         END;
  1512.  
  1513. VAR     yv12Data: YV12DataPtr;
  1514. (* \\\ ------------------------------------------------------------------------- *)
  1515.  
  1516. (* /// ----------------------- "PROCEDURE DecodeYV12()" ------------------------ *)
  1517. PROCEDURE DecodeYV12 {"_DecodeYV12"} (from{8}: e.APTR;
  1518.                                       to{9}: e.APTR;
  1519.                                       width{0}: LONGINT;
  1520.                                       height{1}: LONGINT;
  1521.                                       encSize{2}: LONGINT;
  1522.                                       spec{10}: e.APTR);
  1523.  
  1524. PROCEDURE SelectYV12Funcs {"_SelectYV12Funcs"} (spec{8}: YV12DataPtr;
  1525.                                                 reduce{0}: BOOLEAN;
  1526.                                                 dither{1}: BOOLEAN);
  1527.  
  1528. PROCEDURE SetupYV12(codec: CodecHeader);
  1529. BEGIN
  1530.   IF yv12Data=NIL THEN NEW(yv12Data); END;
  1531.   yv12Data.gray:=grayScale;
  1532.   yv12Data.yuvTab:=ys.GenYUVTables();
  1533.   yv12Data.limit:=ys.InitLimitTables();
  1534.   yv12Data.cmap:=cmap;
  1535.   SelectYV12Funcs(yv12Data,(colorReduction & ~ham8) OR grayScale,o.dither);
  1536.   decoderProc:=DecodeYV12;
  1537.   decoderSpec:=yv12Data;
  1538. END SetupYV12;
  1539. (* \\\ ------------------------------------------------------------------------- *)
  1540.  
  1541. (* /// ----------------------- "PROCEDURE CodecQuery()" ------------------------ *)
  1542. PROCEDURE CodecQuery * (VAR codec: CodecHeader): LONGINT;
  1543.  
  1544. VAR     ret: LONGINT;
  1545.  
  1546. BEGIN
  1547.   ret:=codecSupported;
  1548.   IF codec.depth>32 THEN
  1549.     DEC(codec.depth,32);
  1550.     grayScale:=TRUE;
  1551.     Init332ColorMap();
  1552.   END;
  1553.  
  1554.   CASE codec.compression OF
  1555.   | idcvid,
  1556.     idCVID:
  1557.       codec.compression:=idCVID;
  1558.       codec.description:="Radius Cinepak";
  1559.       codec.width:=i2m.Round(codec.width,4);
  1560.       codec.height:=i2m.Round(codec.height,4);
  1561.       IF (codec.depth=8) OR (codec.depth=16) OR (codec.depth=24) OR (codec.depth=32) THEN
  1562.         SetupCVID(codec);
  1563.         rawDecoderProc:=decoderProc;
  1564.       ELSE
  1565.         ret:=codecUnsupported;
  1566.       END;
  1567.   | idjpeg,
  1568.     idJPEG,
  1569.     idmJPG,
  1570.     idMJPG:
  1571.       IF (codec.compression=idMJPG) OR (codec.compression=idmJPG) THEN
  1572.         codec.compression:=idMJPG;
  1573.         codec.description:="Motion JPEG";
  1574.       ELSE
  1575.         codec.compression:=idJPEG;
  1576.         codec.description:="JFIF JPEG";
  1577.       END;
  1578.       codec.width:=i2m.Round(codec.width,4);
  1579.       codec.height:=i2m.Round(codec.height,2);
  1580.       IF (codec.depth=8) OR (codec.depth=24) THEN
  1581.         SetupJPEG(codec);
  1582.         rawDecoderProc:=decoderProc;
  1583.       ELSE
  1584.         ret:=codecUnsupported;
  1585.       END;
  1586.   | idmsvc,
  1587.     idMSVC,
  1588.     idCRAM:
  1589.       codec.compression:=idMSVC;
  1590.       codec.description:="Microsoft Video 1";
  1591.       codec.width:=i2m.Round(codec.width,4);
  1592.       codec.height:=i2m.Round(codec.height,4);
  1593.       IF codec.depth=8 THEN
  1594.         SetupMSVC8(codec);
  1595.         rawDecoderProc:=decoderProc;
  1596.       ELSIF codec.depth=16 THEN
  1597.         SetupMSVC16(codec);
  1598.         rawDecoderProc:=decoderProc;
  1599.       ELSE
  1600.         ret:=codecUnsupported;
  1601.       END;
  1602.   | idrgb,
  1603.     idRGB:
  1604.       codec.compression:=idRGB;
  1605.       codec.description:="Microsoft RGB";
  1606.       IF codec.depth=4 THEN
  1607.         SetupRGB4(codec);
  1608.         rawDecoderProc:=decoderProc;
  1609.       ELSIF codec.depth=8 THEN
  1610.         SetupRGB8(codec);
  1611.         rawDecoderProc:=decoderProc;
  1612.       ELSIF codec.depth=16 THEN
  1613.         SetupRGB16(codec);
  1614.         rawDecoderProc:=decoderProc;
  1615.       ELSIF codec.depth=24 THEN
  1616.         SetupRGB24(codec);
  1617.         rawDecoderProc:=decoderProc;
  1618.       ELSIF codec.depth=32 THEN
  1619.         SetupRGB32(codec);
  1620.         rawDecoderProc:=decoderProc;
  1621.       ELSE
  1622.         ret:=codecUnsupported;
  1623.       END;
  1624.   | idrle8,
  1625.     idRLE8:
  1626.       codec.compression:=idRLE8;
  1627.       codec.description:="Microsoft RLE8";
  1628.       IF codec.depth=8 THEN
  1629.         SetupRGB8(codec);
  1630.         rawDecoderProc:=decoderProc;
  1631.         SetupRLE8(codec);
  1632.       ELSE
  1633.         ret:=codecUnsupported;
  1634.       END;
  1635.   | idulti,
  1636.     idULTI:
  1637.       codec.compression:=idULTI;
  1638.       codec.description:="IBM Ultimotion";
  1639.       codec.width:=i2m.Round(codec.width,8);
  1640.       codec.height:=i2m.Round(codec.height,8);
  1641.       IF codec.depth=16 THEN
  1642.         SetupULTI(codec);
  1643.         rawDecoderProc:=decoderProc;
  1644.       ELSE
  1645.         ret:=codecUnsupported;
  1646.       END;
  1647.   | idyuv2,
  1648.     idYUV2,
  1649.     id2vuy,
  1650.     id2VUY,
  1651.     idVYUY:
  1652.       IF codec.compression=idVYUY THEN
  1653.         codec.compression:=idVYUY;
  1654.         codec.description:="Component Video (YUV2) Type B"; (* vielleicht auch "ATI Packed YUV" *)
  1655.       ELSE
  1656.         codec.compression:=idYUV2;
  1657.         codec.description:="Component Video (YUV2) Type A";
  1658.       END;
  1659.       codec.width:=i2m.Round(codec.width,2);
  1660.       codec.height:=i2m.Round(codec.height,2);
  1661.       IF (codec.depth=16) OR (codec.depth=24) OR (codec.depth=32) THEN
  1662.         SetupYUV2(codec);
  1663.         rawDecoderProc:=decoderProc;
  1664.       ELSE
  1665.         ret:=codecUnsupported;
  1666.       END;
  1667.   | idYUV9,
  1668.     idYVU9,
  1669.     id9VUY,
  1670.     id9UVY:
  1671.       codec.compression:=idYUV9;
  1672.       codec.description:="Intel Raw (YUV9)";
  1673.       codec.width:=i2m.Round(codec.width,4);
  1674.       codec.height:=i2m.Round(codec.height,4);
  1675.       IF (codec.depth=9) OR (codec.depth=16) OR (codec.depth=24) OR (codec.depth=32) THEN
  1676.         SetupYUV9(codec);
  1677.         rawDecoderProc:=decoderProc;
  1678.       ELSE
  1679.         ret:=codecUnsupported;
  1680.       END;
  1681.   | idyv12,
  1682.     idYV12:
  1683.       codec.compression:=idYV12;
  1684.       codec.description:="YUV12 Planar MPEG";
  1685.       IF (codec.depth=12) OR (codec.depth=16) OR (codec.depth=24) OR (codec.depth=32) THEN
  1686.         SetupYV12(codec);
  1687.         rawDecoderProc:=decoderProc;
  1688.       ELSE
  1689.         ret:=codecUnsupported;
  1690.       END;
  1691.   | idxmpg,
  1692.     idXMPG:
  1693.       codec.compression:=idXMPG;
  1694.       codec.description:="Editable MPEG";
  1695.       ret:=codecUnsupported;
  1696.   | idIJPG:
  1697.       codec.description:="Intergraph JPEG";
  1698.       ret:=codecUnsupported;
  1699.   | idrle4,
  1700.     idRLE4:
  1701.       codec.compression:=idRLE4;
  1702.       codec.description:="Microsoft RLE4";
  1703.       ret:=codecUnsupported;
  1704.   | idrt21,
  1705.     idRT21:
  1706.       codec.compression:=idRT21;
  1707.       codec.description:="Intel Indeo R2.1";
  1708.       ret:=codecUnsupported;
  1709.   | idiv31,
  1710.     idIV31:
  1711.       codec.compression:=idIV31;
  1712.       codec.description:="Intel Indeo R3.1";
  1713.       ret:=codecUnsupported;
  1714.   | idiv32,
  1715.     idIV32:
  1716.       codec.compression:=idIV32;
  1717.       codec.description:="Intel Indeo R3.2";
  1718. (*
  1719.       codec.width:=i2m.Round(codec.width,4);
  1720.       codec.height:=i2m.Round(codec.height,4);
  1721.       SetupIV32(codec);
  1722.       ret:=codecSupported;
  1723. *)
  1724.       ret:=codecUnsupported;
  1725.   | idiv41,
  1726.     idIV41:
  1727.       codec.compression:=idIV41;
  1728.       codec.description:="Intel Indeo R4.1";
  1729.       ret:=codecUnsupported;
  1730.   | idcyuv,
  1731.     idCYUV:
  1732.       codec.compression:=idCYUV;
  1733.       codec.description:="Creative Technology (CYUV)";
  1734.       ret:=codecUnsupported;
  1735.   | idVDOW:
  1736.       codec.description:="VDONet Video";
  1737.       ret:=codecUnsupported;
  1738.   ELSE
  1739.     ret:=codecUnknown;
  1740.   END;
  1741.   RETURN ret;
  1742. END CodecQuery;
  1743. (* \\\ ------------------------------------------------------------------------- *)
  1744.  
  1745. (* /// ------------------------- "PROCEDURE FastC2P()" ------------------------- *)
  1746. PROCEDURE FastC2P4 {"_FastC2P4"} (chunky{8}: e.APTR;
  1747.                                   bitmap{9}: gfx.BitMapPtr;
  1748.                                   realWidth{1}: LONGINT);
  1749.  
  1750. PROCEDURE FastC2P8 {"_FastC2P8"} (chunky{8}: e.APTR;
  1751.                                   bitmap{9}: gfx.BitMapPtr;
  1752.                                   realWidth{1}: LONGINT);
  1753. (* \\\ ------------------------------------------------------------------------- *)
  1754.  
  1755. (* /// ------------------------ "PROCEDURE RGBtoHAM8()" ------------------------ *)
  1756. PROCEDURE RGBtoHAM8 {"_RGBtoHAM8"} (rgb{8}: e.APTR;
  1757.                                     ham8{9}: e.APTR;
  1758.                                     width{0}: LONGINT;
  1759.                                     height{1}: LONGINT);
  1760. (* \\\ ------------------------------------------------------------------------- *)
  1761.  
  1762. (* /// ---------------------- "PROCEDURE DisplayFrame()" ----------------------- *)
  1763. PROCEDURE DisplayFrameDummy();
  1764. BEGIN
  1765. END DisplayFrameDummy;
  1766.  
  1767. PROCEDURE DisplayFrameAGA();
  1768. BEGIN
  1769.   gfx.WaitBlit();
  1770.   IF ham8 THEN
  1771.     RGBtoHAM8(videoDataDec,ham8Buffer,calcWidth,calcHeight);
  1772.     fastc2pProc(ham8Buffer,tmpBM,calcWidth);
  1773.   ELSE
  1774.     fastc2pProc(videoDataDec,tmpBM,calcWidth);
  1775.   END;
  1776.   gfx.BltBitMapRastPort(tmpBM,0,0,rp,leftOff,topOff,animWidth,animHeight,y.VAL(y.BYTE,0C0H));
  1777. END DisplayFrameAGA;
  1778.  
  1779. PROCEDURE DisplayFrameCyberGfx();
  1780.  
  1781. VAR     width: INTEGER;
  1782.         height: INTEGER;
  1783.  
  1784. BEGIN
  1785.   IF pubScreen THEN
  1786.     IF animDepth>8 THEN
  1787.       width:=window.width-(window.borderLeft+window.borderRight);
  1788.       height:=window.height-(window.borderTop+window.borderBottom);
  1789.       IF (width#animWidth) OR (height#animHeight) THEN
  1790.         y.SETREG(0,cgfx.ScalePixelArray(videoDataDec,animWidth,animHeight,dispModulo,rp,leftOff,topOff,width,height,colorType));
  1791.       ELSE
  1792.         y.SETREG(0,cgfx.WritePixelArray(videoDataDec,0,0,dispModulo,rp,leftOff,topOff,animWidth,animHeight,colorType));
  1793.       END;
  1794.     ELSE
  1795.       y.SETREG(0,cgfx.WriteLUTPixelArray(videoDataDec,0,0,dispModulo,rp,cmap,leftOff,topOff,animWidth,animHeight,cgfx.fmtXRGB8));
  1796.     END;
  1797.   ELSE
  1798.     y.SETREG(0,cgfx.WritePixelArray(videoDataDec,0,0,dispModulo,rp,leftOff,topOff,animWidth,animHeight,colorType));
  1799.   END;
  1800. END DisplayFrameCyberGfx;
  1801. (* \\\ ------------------------------------------------------------------------- *)
  1802.  
  1803. (* /// ----------------------- "PROCEDURE DecodeFrame()" ----------------------- *)
  1804. PROCEDURE DecodeFrame * (size: LONGINT;
  1805.                          raw: BOOLEAN);
  1806. BEGIN
  1807.   io.Read(videoData,size);
  1808.   IF raw & (size>=frameSize) THEN (* Workaround für kaputte MAB-AVIs, MAB speichert bei RLE oft 00db statt 00dc *)
  1809.     (* rawDecoderProc(videoData,videoDataDec,calcWidth,calcHeight,size,decoderSpec); *)
  1810.   ELSE
  1811.     decoderProc(videoData,videoDataDec,calcWidth,calcHeight,size,decoderSpec);
  1812.   END;
  1813. (*
  1814.   IF iv32Data#NIL THEN
  1815.     d.PrintF("%08lx\n",videoData);
  1816.     d.PrintF("%08lx\t%08lx\n",ivm1,ivm4);
  1817.     d.PrintF("%08lx\t%08lx\t%08lx%3ld\t\t%08lx\t%08lx\t%08lx\n",iv32Data.x[0],iv32Data.x[1],iv32Data.x[2],iv32Data.x[3],iv32Data.x[4],iv32Data.x[5],iv32Data.x[6]);
  1818.   END;
  1819. *)
  1820.   displayProc();
  1821. END DecodeFrame;
  1822. (* \\\ ------------------------------------------------------------------------- *)
  1823.  
  1824. (* /// ---------------------- "PROCEDURE ReadColorMap()" ----------------------- *)
  1825. PROCEDURE ReadColorMap * (colorCnt: LONGINT;
  1826.                           palChange: BOOLEAN);
  1827.  
  1828. TYPE    color=ARRAY 4 OF CHAR;
  1829.  
  1830. VAR     cnt: LONGINT;
  1831.         cReg: color;
  1832.         grayColor: LONGINT;
  1833.  
  1834. BEGIN
  1835.   grayScale:=o.grayScale;
  1836.   IF colorCnt=0 THEN (* =0 bedeutet TrueColor *)
  1837.     DISPOSE(colorMap);
  1838.     DISPOSE(secondColorMap);
  1839.   ELSE
  1840.     IF colorMap=NIL THEN NEW(colorMap); END;
  1841.     colorMap.count:=256; (* müßte colorCnt sein, kann aber Probleme geben *)
  1842.     colorMap.first:=0;
  1843.     colorMap.last:=255; (* müßte colorCnt-1 sein, kann aber Probleme geben *)
  1844.     FOR cnt:=0 TO colorCnt-1 DO
  1845.       cReg:=y.VAL(color,io.GetLSBLong());
  1846.       IF grayScale THEN
  1847.         grayColor:=i2m.ByteTo32(CHR(y.LSH(ORD(cReg[1])*11+ORD(cReg[2])*16+ORD(cReg[3])*5,-5)));
  1848.         colorMap.colors[cnt].red:=grayColor;
  1849.         colorMap.colors[cnt].green:=grayColor;
  1850.         colorMap.colors[cnt].blue:=grayColor;
  1851.         cmap[cnt].red:=CHR(grayColor);
  1852.         cmap[cnt].green:=CHR(grayColor);
  1853.         cmap[cnt].blue:=CHR(grayColor);
  1854.       ELSE
  1855.         colorMap.colors[cnt].red:=i2m.ByteTo32(cReg[1]);
  1856.         colorMap.colors[cnt].green:=i2m.ByteTo32(cReg[2]);
  1857.         colorMap.colors[cnt].blue:=i2m.ByteTo32(cReg[3]);
  1858.         cmap[cnt].red:=cReg[1];
  1859.         cmap[cnt].green:=cReg[2];
  1860.         cmap[cnt].blue:=cReg[3];
  1861.       END;
  1862.     END;
  1863.     IF palChange THEN
  1864.       IF secondColorMap=NIL THEN
  1865.         NEW(secondColorMap);
  1866.         NEW(secondCmap);
  1867.       END;
  1868.       e.CopyMemQuickAPTR(colorMap,secondColorMap,SIZE(colorMap^));
  1869.       e.CopyMemQuickAPTR(cmap,secondCmap,SIZE(cmap^));
  1870.     ELSE
  1871.       DISPOSE(secondColorMap);
  1872.       DISPOSE(secondCmap);
  1873.     END;
  1874.   END;
  1875. END ReadColorMap;
  1876. (* \\\ ------------------------------------------------------------------------- *)
  1877.  
  1878. (* /// --------------------- "PROCEDURE ChangeColorMap()" ---------------------- *)
  1879. PROCEDURE ChangeColorMap * (size: LONGINT);
  1880.  
  1881. TYPE    ColorPair=STRUCT
  1882.             first: CHAR;
  1883.             num: CHAR;
  1884.         END;
  1885.         ColorArr=ARRAY 4 OF CHAR;
  1886.  
  1887. VAR     palInfo: ColorPair;
  1888.         color: ColorArr;
  1889.         first: INTEGER;
  1890.         last: INTEGER;
  1891.         cnt: INTEGER;
  1892.         tcmap: ColorMapArrayPtr;
  1893.         grayColor: LONGINT;
  1894.  
  1895. BEGIN
  1896.   palInfo:=y.VAL(ColorPair,io.GetMSBShort());
  1897.   io.Skip(2);
  1898.   DEC(size,4);
  1899.   first:=ORD(palInfo.first);
  1900.   last:=first+ORD(palInfo.num)-1;
  1901.   IF last<0 THEN last:=255 END;
  1902.   FOR cnt:=first TO last DO
  1903.     color:=y.VAL(ColorArr,io.GetMSBLong());
  1904.     IF grayScale THEN
  1905.       grayColor:=i2m.ByteTo32(CHR(y.LSH(ORD(color[0])*11+ORD(color[1])*16+ORD(color[2])*5,-5)));
  1906.       colorMap.colors[cnt].red:=grayColor;
  1907.       colorMap.colors[cnt].green:=grayColor;
  1908.       colorMap.colors[cnt].blue:=grayColor;
  1909.       cmap[cnt].red:=CHR(grayColor);
  1910.       cmap[cnt].green:=CHR(grayColor);
  1911.       cmap[cnt].blue:=CHR(grayColor);
  1912.     ELSE
  1913.       colorMap.colors[cnt].red:=i2m.ByteTo32(color[0]);
  1914.       colorMap.colors[cnt].green:=i2m.ByteTo32(color[1]);
  1915.       colorMap.colors[cnt].blue:=i2m.ByteTo32(color[2]);
  1916.       cmap[cnt].red:=color[0];
  1917.       cmap[cnt].green:=color[1];
  1918.       cmap[cnt].blue:=color[2];
  1919.     END;
  1920.     DEC(size,4);
  1921.   END;
  1922.   IF ~pubScreen THEN
  1923.     tcmap:=y.VAL(ColorMapArrayPtr,colorMap);
  1924.     gfx.LoadRGB32(y.ADR(screen.viewPort),tcmap^);
  1925.   END;
  1926.   IF size>0 THEN io.Skip(size); END;
  1927. END ChangeColorMap;
  1928. (* \\\ ------------------------------------------------------------------------- *)
  1929.  
  1930. (* /// ------------------- "PROCEDURE Restore1stColorMap()" -------------------- *)
  1931. PROCEDURE Restore1stColorMap * ();
  1932.  
  1933. VAR     tcmap: ColorMapArrayPtr;
  1934.  
  1935. BEGIN
  1936.   IF secondColorMap#NIL THEN
  1937.     e.CopyMemQuickAPTR(secondColorMap,colorMap,SIZE(secondColorMap^));
  1938.     e.CopyMemQuickAPTR(secondCmap,cmap,SIZE(secondCmap^));
  1939.     tcmap:=y.VAL(ColorMapArrayPtr,secondColorMap);
  1940.     gfx.LoadRGB32(y.ADR(screen.viewPort),tcmap^);
  1941.   END;
  1942. END Restore1stColorMap;
  1943. (* \\\ ------------------------------------------------------------------------- *)
  1944.  
  1945. (* /// ---------------------- "PROCEDURE AllocBuffers()" ----------------------- *)
  1946. PROCEDURE AllocBuffers * (): BOOLEAN;
  1947.  
  1948. VAR     codec: CodecHeader;
  1949.         size: LONGINT;
  1950.         ret: BOOLEAN;
  1951.  
  1952. BEGIN
  1953.   colorReduction:=g.agaOnly OR (g.gfxBoth & o.aga) OR (g.cgfxOnly & o.aga);
  1954.   ham8:=o.ham8;
  1955.   ret:=TRUE;
  1956.   animWidth:=i.LongToUInt(g.animInfo.vids.strf.width);
  1957.   animHeight:=i.LongToUInt(g.animInfo.vids.strf.height);
  1958.   animDepth:=i.LongToUInt(g.animInfo.vids.strf.bitCnt);
  1959.   codec.compression:=g.animInfo.vids.strf.compression;
  1960.   codec.width:=g.animInfo.vids.strf.width;
  1961.   codec.height:=g.animInfo.vids.strf.height;
  1962.   codec.depth:=g.animInfo.vids.strf.bitCnt;
  1963.   CASE CodecQuery(codec) OF
  1964.   | codecUnsupported:
  1965.       d.PrintF("  Unsupported video encoding: %s [",y.ADR(codec.description)); cu.PrintFCC(codec.compression); d.PrintF("], depth %ld\n",animDepth);
  1966.       ret:=FALSE;
  1967.       IF (codec.compression=idRT21) OR (codec.compression=idIV31) OR (codec.compression=idIV32) OR (codec.compression=idIV41) THEN d.PrintF("Please consult the manual/FAQ for information about Intel Indeo\n"); END;
  1968.   | codecUnknown:
  1969.       d.PrintF("  Unknown video encoding: "); cu.PrintFCC(codec.compression); d.PrintF(", depth %ld\n",animDepth);
  1970.       ret:=FALSE;
  1971.   ELSE
  1972.     calcWidth:=codec.width;
  1973.     calcHeight:=codec.height;
  1974.     animDepth:=i.LongToUInt(codec.depth); (* Tiefe kann sich geändert haben! *)
  1975.     IF ~o.quiet THEN
  1976.       d.PrintF("  Video: %s, %ld bit, %ld×%ld, %ld fps\n",y.ADR(codec.description),
  1977.                                                           animDepth,
  1978.                                                           animWidth,
  1979.                                                           animHeight,
  1980.                                                           s.GetFPS());
  1981.     END;
  1982.     DISPOSE(videoData);
  1983.     DISPOSE(ham8Buffer);
  1984.     DISPOSE(videoDataDec);
  1985.     frameSize:=i2m.Round(calcWidth*calcHeight,2); (* ungerade Größen ergeben Mungwall-Hits *)
  1986.     dispModulo:=i.LongToUInt(calcWidth);
  1987.     videoBufferSize:=i2m.Round(g.animInfo.vids.strh.suggestedBufferSize,2); (* ungerade Größen ergeben Mungwall-Hits *)
  1988.     IF (videoBufferSize>frameSize) & (videoBufferSize>frameSize*3) OR (videoBufferSize<g.animInfo.avih.suggestedBufferSize) THEN videoBufferSize:=0; END;
  1989.     IF animDepth<=8 THEN
  1990.       ham8:=FALSE;
  1991.       IF videoBufferSize=0 THEN videoBufferSize:=frameSize*2; END; (* 2fache Größe, manche Videos sind leicht schrottig *)
  1992.       colorType:=cgfx.rectFmtLUT8;
  1993.     ELSE
  1994.       IF ham8 THEN ol.New(ham8Buffer,frameSize); END;
  1995.       IF grayScale THEN
  1996.         colorType:=cgfx.rectFmtGREY8;
  1997.       ELSE
  1998.         colorType:=cgfx.rectFmtRGB;
  1999.         dispModulo:=dispModulo*3;
  2000.         frameSize:=frameSize*3;
  2001.       END;
  2002.       IF videoBufferSize=0 THEN videoBufferSize:=frameSize*2; END; (* 2fache Größe, manche Videos sind leicht schrottig *)
  2003.     END;
  2004.     ol.New(videoData,videoBufferSize);
  2005.     ol.New(videoDataDec,frameSize);
  2006.     IF ~o.noVideo THEN
  2007.       IF colorReduction THEN
  2008.         displayProc:=DisplayFrameAGA;
  2009.         IF animDepth=4 THEN
  2010.           fastc2pProc:=FastC2P4;
  2011.         ELSE
  2012.           fastc2pProc:=FastC2P8;
  2013.         END;
  2014.       ELSE
  2015.         displayProc:=DisplayFrameCyberGfx;
  2016.       END;
  2017.     ELSE
  2018.       displayProc:=DisplayFrameDummy;
  2019.       colorReduction:=FALSE;
  2020.     END;
  2021.   END;
  2022.   RETURN ret;
  2023. END AllocBuffers;
  2024. (* \\\ ------------------------------------------------------------------------- *)
  2025.  
  2026. BEGIN
  2027.   NEW(cmap);
  2028. CLOSE
  2029.   CloseDisplay();
  2030. END CyberAVIVideo.
  2031.  
  2032.